diff --git a/package.json b/package.json index 2d47c85..a576763 100644 --- a/package.json +++ b/package.json @@ -8,8 +8,8 @@ }, "files": ["src", "universe.*"], "dependencies": { - "crossfilter2": "1.4.1", - "reductio": "^0.6.2" + "crossfilter2": "1.4.6", + "reductio": "^0.6.3" }, "devDependencies": { "ava": "^0.15.2", diff --git a/src/crossfilter.js b/src/crossfilter.js index c374f24..b09036f 100644 --- a/src/crossfilter.js +++ b/src/crossfilter.js @@ -55,21 +55,37 @@ module.exports = function (service) { return promise.then(data) }, Promise.resolve(true)) }) + + .then(function() { + return Promise.all(_.map(service.filterListeners, function (listener) { + return listener() + })) + }) + .then(function () { return service }) } - function remove() { + function remove(predicate) { return new Promise(function (resolve, reject) { try { - resolve(service.cf.remove()) + resolve(service.cf.remove(predicate)) } catch (err) { reject(err) } }) - .then(function () { - return service - }) + + .then(function() { + return Promise.all(_.map(service.filterListeners, function (listener) { + return listener() + })) + }) + + .then(function () { + return service + }) } } + + diff --git a/universe.js b/universe.js new file mode 100644 index 0000000..e55e7a8 --- /dev/null +++ b/universe.js @@ -0,0 +1,6736 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.universe = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= length) return array; + var copy = new array.constructor(length); + copy.set(array); + return copy; + }; + + var crossfilter_arrayWiden = function(array, width) { + var copy; + switch (width) { + case 16: copy = crossfilter_array16(array.length); break; + case 32: copy = crossfilter_array32(array.length); break; + default: throw new Error("invalid array width!"); + } + copy.set(array); + return copy; + }; +} + +function crossfilter_arrayUntyped(n) { + var array = new Array(n), i = -1; + while (++i < n) array[i] = 0; + return array; +} + +function crossfilter_arrayLengthenUntyped(array, length) { + var n = array.length; + while (n < length) array[n++] = 0; + return array; +} + +function crossfilter_arrayWidenUntyped(array, width) { + if (width > 32) throw new Error("invalid array width!"); + return array; +} + +// An arbitrarily-wide array of bitmasks +function crossfilter_bitarray(n) { + this.length = n; + this.subarrays = 1; + this.width = 8; + this.masks = { + 0: 0 + } + + this[0] = crossfilter_array8(n); +} + +crossfilter_bitarray.prototype.lengthen = function(n) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + this[i] = crossfilter_arrayLengthen(this[i], n); + } + this.length = n; +}; + +// Reserve a new bit index in the array, returns {offset, one} +crossfilter_bitarray.prototype.add = function() { + var m, w, one, i, len; + + for (i = 0, len = this.subarrays; i < len; ++i) { + m = this.masks[i]; + w = this.width - (32 * i); + one = ~m & -~m; + + if (w >= 32 && !one) { + continue; + } + + if (w < 32 && (one & (1 << w))) { + // widen this subarray + this[i] = crossfilter_arrayWiden(this[i], w <<= 1); + this.width = 32 * i + w; + } + + this.masks[i] |= one; + + return { + offset: i, + one: one + }; + } + + // add a new subarray + this[this.subarrays] = crossfilter_array8(this.length); + this.masks[this.subarrays] = 1; + this.width += 8; + return { + offset: this.subarrays++, + one: 1 + }; +}; + +// Copy record from index src to index dest +crossfilter_bitarray.prototype.copy = function(dest, src) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + this[i][dest] = this[i][src]; + } +}; + +// Truncate the array to the given length +crossfilter_bitarray.prototype.truncate = function(n) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + for (var j = this.length - 1; j >= n; j--) { + this[i][j] = 0; + } + this[i].length = n; + } + this.length = n; +}; + +// Checks that all bits for the given index are 0 +crossfilter_bitarray.prototype.zero = function(n) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + if (this[i][n]) { + return false; + } + } + return true; +}; + +// Checks that all bits for the given index are 0 except for possibly one +crossfilter_bitarray.prototype.zeroExcept = function(n, offset, zero) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + if (i === offset ? this[i][n] & zero : this[i][n]) { + return false; + } + } + return true; +}; + +// Checks that all bits for the given indez are 0 except for the specified mask. +// The mask should be an array of the same size as the filter subarrays width. +crossfilter_bitarray.prototype.zeroExceptMask = function(n, mask) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + if (this[i][n] & mask[i]) { + return false; + } + } + return true; +} + +// Checks that only the specified bit is set for the given index +crossfilter_bitarray.prototype.only = function(n, offset, one) { + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + if (this[i][n] != (i === offset ? one : 0)) { + return false; + } + } + return true; +}; + +// Checks that only the specified bit is set for the given index except for possibly one other +crossfilter_bitarray.prototype.onlyExcept = function(n, offset, zero, onlyOffset, onlyOne) { + var mask; + var i, len; + for (i = 0, len = this.subarrays; i < len; ++i) { + mask = this[i][n]; + if (i === offset) + mask &= zero; + if (mask != (i === onlyOffset ? onlyOne : 0)) { + return false; + } + } + return true; +}; + +module.exports = { + array8: crossfilter_arrayUntyped, + array16: crossfilter_arrayUntyped, + array32: crossfilter_arrayUntyped, + arrayLengthen: crossfilter_arrayLengthenUntyped, + arrayWiden: crossfilter_arrayWidenUntyped, + bitarray: crossfilter_bitarray +}; + +},{}],4:[function(require,module,exports){ +'use strict'; + +var crossfilter_identity = require('./identity'); + +function bisect_by(f) { + + // Locate the insertion point for x in a to maintain sorted order. The + // arguments lo and hi may be used to specify a subset of the array which + // should be considered; by default the entire array is used. If x is already + // present in a, the insertion point will be before (to the left of) any + // existing entries. The return value is suitable for use as the first + // argument to `array.splice` assuming that a is already sorted. + // + // The returned insertion point i partitions the array a into two halves so + // that all v < x for v in a[lo:i] for the left side and all v >= x for v in + // a[i:hi] for the right side. + function bisectLeft(a, x, lo, hi) { + while (lo < hi) { + var mid = lo + hi >>> 1; + if (f(a[mid]) < x) lo = mid + 1; + else hi = mid; + } + return lo; + } + + // Similar to bisectLeft, but returns an insertion point which comes after (to + // the right of) any existing entries of x in a. + // + // The returned insertion point i partitions the array into two halves so that + // all v <= x for v in a[lo:i] for the left side and all v > x for v in + // a[i:hi] for the right side. + function bisectRight(a, x, lo, hi) { + while (lo < hi) { + var mid = lo + hi >>> 1; + if (x < f(a[mid])) hi = mid; + else lo = mid + 1; + } + return lo; + } + + bisectRight.right = bisectRight; + bisectRight.left = bisectLeft; + return bisectRight; +} + +module.exports = bisect_by(crossfilter_identity); +module.exports.by = bisect_by; // assign the raw function to the export as well + +},{"./identity":9}],5:[function(require,module,exports){ +'use strict'; + +var xfilterArray = require('./array'); +var xfilterFilter = require('./filter'); +var crossfilter_identity = require('./identity'); +var crossfilter_null = require('./null'); +var crossfilter_zero = require('./zero'); +var xfilterHeapselect = require('./heapselect'); +var xfilterHeap = require('./heap'); +var bisect = require('./bisect'); +var insertionsort = require('./insertionsort'); +var permute = require('./permute'); +var quicksort = require('./quicksort'); +var xfilterReduce = require('./reduce'); +var packageJson = require('./../package.json'); // require own package.json for the version field +var result = require('lodash.result'); + +// constants +var REMOVED_INDEX = -1; + +// expose API exports +exports.crossfilter = crossfilter; +exports.crossfilter.heap = xfilterHeap; +exports.crossfilter.heapselect = xfilterHeapselect; +exports.crossfilter.bisect = bisect; +exports.crossfilter.insertionsort = insertionsort; +exports.crossfilter.permute = permute; +exports.crossfilter.quicksort = quicksort; +exports.crossfilter.version = packageJson.version; // please note use of "package-json-versionify" transform + +function crossfilter() { + var crossfilter = { + add: add, + remove: removeData, + dimension: dimension, + groupAll: groupAll, + size: size, + all: all, + allFiltered: allFiltered, + onChange: onChange, + isElementFiltered: isElementFiltered + }; + + var data = [], // the records + n = 0, // the number of records; data.length + filters, // 1 is filtered out + filterListeners = [], // when the filters change + dataListeners = [], // when data is added + removeDataListeners = [], // when data is removed + callbacks = []; + + filters = new xfilterArray.bitarray(0); + + // Adds the specified new records to this crossfilter. + function add(newData) { + var n0 = n, + n1 = newData.length; + + // If there's actually new data to add… + // Merge the new data into the existing data. + // Lengthen the filter bitset to handle the new records. + // Notify listeners (dimensions and groups) that new data is available. + if (n1) { + data = data.concat(newData); + filters.lengthen(n += n1); + dataListeners.forEach(function(l) { l(newData, n0, n1); }); + triggerOnChange('dataAdded'); + } + + return crossfilter; + } + + // Removes all records that match the current filters, or if a predicate function is passed, + // removes all records matching the predicate (ignoring filters). + function removeData(predicate) { + var // Mapping from old record indexes to new indexes (after records removed) + newIndex = crossfilter_index(n, n), + removed = [], + usePred = typeof predicate === 'function', + shouldRemove = function (i) { + return usePred ? predicate(data[i], i) : filters.zero(i) + }; + + for (var index1 = 0, index2 = 0; index1 < n; ++index1) { + if ( shouldRemove(index1) ) { + removed.push(index1); + newIndex[index1] = REMOVED_INDEX; + } else { + newIndex[index1] = index2++; + } + } + + // Remove all matching records from groups. + filterListeners.forEach(function(l) { l(-1, -1, [], removed, true); }); + + // Update indexes. + removeDataListeners.forEach(function(l) { l(newIndex); }); + + // Remove old filters and data by overwriting. + for (var index3 = 0, index4 = 0; index3 < n; ++index3) { + if ( newIndex[index3] !== REMOVED_INDEX ) { + if (index3 !== index4) filters.copy(index4, index3), data[index4] = data[index3]; + ++index4; + } + } + + data.length = n = index4; + filters.truncate(index4); + triggerOnChange('dataRemoved'); + } + + // Return true if the data element at index i is filtered IN. + // Optionally, ignore the filters of any dimensions in the ignore_dimensions list. + function isElementFiltered(i, ignore_dimensions) { + var n, + d, + id, + len, + mask = Array(filters.subarrays); + for (n = 0; n < filters.subarrays; n++) { mask[n] = ~0; } + if (ignore_dimensions) { + for (d = 0, len = ignore_dimensions.length; d < len; d++) { + // The top bits of the ID are the subarray offset and the lower bits are the bit + // offset of the "one" mask. + id = ignore_dimensions[d].id(); + mask[id >> 7] &= ~(0x1 << (id & 0x3f)); + } + } + return filters.zeroExceptMask(i,mask); + } + + // Adds a new dimension with the specified value accessor function. + function dimension(value, iterable) { + + if (typeof value === 'string') { + var accessorPath = value; + value = function(d) { return result(d, accessorPath); }; + } + + var dimension = { + filter: filter, + filterExact: filterExact, + filterRange: filterRange, + filterFunction: filterFunction, + filterAll: filterAll, + top: top, + bottom: bottom, + group: group, + groupAll: groupAll, + dispose: dispose, + remove: dispose, // for backwards-compatibility + accessor: value, + id: function() { return id; } + }; + + var one, // lowest unset bit as mask, e.g., 00001000 + zero, // inverted one, e.g., 11110111 + offset, // offset into the filters arrays + id, // unique ID for this dimension (reused when dimensions are disposed) + values, // sorted, cached array + index, // maps sorted value index -> record index (in data) + newValues, // temporary array storing newly-added values + newIndex, // temporary array storing newly-added index + iterablesIndexCount, + newIterablesIndexCount, + iterablesIndexFilterStatus, + newIterablesIndexFilterStatus, + iterablesEmptyRows = [], + sort = quicksort.by(function(i) { return newValues[i]; }), + refilter = xfilterFilter.filterAll, // for recomputing filter + refilterFunction, // the custom filter function in use + indexListeners = [], // when data is added + dimensionGroups = [], + lo0 = 0, + hi0 = 0, + t = 0, + k; + + // Updating a dimension is a two-stage process. First, we must update the + // associated filters for the newly-added records. Once all dimensions have + // updated their filters, the groups are notified to update. + dataListeners.unshift(preAdd); + dataListeners.push(postAdd); + + removeDataListeners.push(removeData); + + // Add a new dimension in the filter bitmap and store the offset and bitmask. + var tmp = filters.add(); + offset = tmp.offset; + one = tmp.one; + zero = ~one; + + // Create a unique ID for the dimension + // IDs will be re-used if dimensions are disposed. + // For internal use the ID is the subarray offset shifted left 7 bits or'd with the + // bit offset of the set bit in the dimension's "one" mask. + id = (offset << 7) | (Math.log(one) / Math.log(2)); + + preAdd(data, 0, n); + postAdd(data, 0, n); + + // Incorporates the specified new records into this dimension. + // This function is responsible for updating filters, values, and index. + function preAdd(newData, n0, n1) { + + if (iterable){ + // Count all the values + t = 0; + j = 0; + k = []; + + for (var i0 = 0; i0 < newData.length; i0++) { + for(j = 0, k = value(newData[i0]); j < k.length; j++) { + t++; + } + } + + newValues = []; + newIterablesIndexCount = crossfilter_range(newData.length); + newIterablesIndexFilterStatus = crossfilter_index(t,1); + var unsortedIndex = crossfilter_range(t); + + for (var l = 0, index1 = 0; index1 < newData.length; index1++) { + k = value(newData[index1]) + // + if(!k.length){ + newIterablesIndexCount[index1] = 0; + iterablesEmptyRows.push(index1 + n0); + continue; + } + newIterablesIndexCount[index1] = k.length + for (j = 0; j < k.length; j++) { + newValues.push(k[j]); + unsortedIndex[l] = index1; + l++; + } + } + + // Create the Sort map used to sort both the values and the valueToData indices + var sortMap = sort(crossfilter_range(t), 0, t); + + // Use the sortMap to sort the newValues + newValues = permute(newValues, sortMap); + + + // Use the sortMap to sort the unsortedIndex map + // newIndex should be a map of sortedValue -> crossfilterData + newIndex = permute(unsortedIndex, sortMap) + + } else{ + // Permute new values into natural order using a standard sorted index. + newValues = newData.map(value); + newIndex = sort(crossfilter_range(n1), 0, n1); + newValues = permute(newValues, newIndex); + } + + if(iterable) { + n1 = t; + } + + // Bisect newValues to determine which new records are selected. + var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1]; + if (refilterFunction) { + for (var index2 = 0; index2 < n1; ++index2) { + if (!refilterFunction(newValues[index2], index2)) { + filters[offset][newIndex[index2] + n0] |= one; + if(iterable) newIterablesIndexFilterStatus[index2] = 1; + } + } + } else { + for (var index3 = 0; index3 < lo1; ++index3) { + filters[offset][newIndex[index3] + n0] |= one; + if(iterable) newIterablesIndexFilterStatus[index3] = 1; + } + for (var index4 = hi1; index4 < n1; ++index4) { + filters[offset][newIndex[index4] + n0] |= one; + if(iterable) newIterablesIndexFilterStatus[index4] = 1; + } + } + + // If this dimension previously had no data, then we don't need to do the + // more expensive merge operation; use the new values and index as-is. + if (!n0) { + values = newValues; + index = newIndex; + iterablesIndexCount = newIterablesIndexCount; + iterablesIndexFilterStatus = newIterablesIndexFilterStatus; + lo0 = lo1; + hi0 = hi1; + return; + } + + + + var oldValues = values, + oldIndex = index, + oldIterablesIndexFilterStatus = iterablesIndexFilterStatus, + old_n0, + i1 = 0; + + i0 = 0; + + if(iterable){ + old_n0 = n0 + n0 = oldValues.length; + n1 = t + } + + // Otherwise, create new arrays into which to merge new and old. + values = iterable ? new Array(n0 + n1) : new Array(n); + index = iterable ? new Array(n0 + n1) : crossfilter_index(n, n); + if(iterable) iterablesIndexFilterStatus = crossfilter_index(n0 + n1, 1); + + // Concatenate the newIterablesIndexCount onto the old one. + if(iterable) { + var oldiiclength = iterablesIndexCount.length; + iterablesIndexCount = xfilterArray.arrayLengthen(iterablesIndexCount, n); + for(var j=0; j+oldiiclength < n; j++) { + iterablesIndexCount[j+oldiiclength] = newIterablesIndexCount[j]; + } + } + + // Merge the old and new sorted values, and old and new index. + var index5 = 0; + for (; i0 < n0 && i1 < n1; ++index5) { + if (oldValues[i0] < newValues[i1]) { + values[index5] = oldValues[i0]; + if(iterable) iterablesIndexFilterStatus[index5] = oldIterablesIndexFilterStatus[i0]; + index[index5] = oldIndex[i0++]; + } else { + values[index5] = newValues[i1]; + if(iterable) iterablesIndexFilterStatus[index5] = newIterablesIndexFilterStatus[i1]; + index[index5] = newIndex[i1++] + (iterable ? old_n0 : n0); + } + } + + // Add any remaining old values. + for (; i0 < n0; ++i0, ++index5) { + values[index5] = oldValues[i0]; + if(iterable) iterablesIndexFilterStatus[index5] = oldIterablesIndexFilterStatus[i0]; + index[index5] = oldIndex[i0]; + } + + // Add any remaining new values. + for (; i1 < n1; ++i1, ++index5) { + values[index5] = newValues[i1]; + if(iterable) iterablesIndexFilterStatus[index5] = newIterablesIndexFilterStatus[i1]; + index[index5] = newIndex[i1] + (iterable ? old_n0 : n0); + } + + // Bisect again to recompute lo0 and hi0. + bounds = refilter(values), lo0 = bounds[0], hi0 = bounds[1]; + } + + // When all filters have updated, notify index listeners of the new values. + function postAdd(newData, n0, n1) { + indexListeners.forEach(function(l) { l(newValues, newIndex, n0, n1); }); + newValues = newIndex = null; + } + + function removeData(reIndex) { + if (iterable) { + for (var i0 = 0, i1 = 0; i0 < iterablesEmptyRows.length; i0++) { + if (reIndex[iterablesEmptyRows[i0]] !== REMOVED_INDEX) { + iterablesEmptyRows[i1] = reIndex[iterablesEmptyRows[i0]]; + i1++; + } + } + iterablesEmptyRows.length = i1; + for (i0 = 0, i1 = 0; i0 < n; i0++) { + if (reIndex[i0] !== REMOVED_INDEX) { + if (i1 !== i0) iterablesIndexCount[i1] = iterablesIndexCount[i0]; + i1++; + } + } + iterablesIndexCount.length = i1; + } + // Rewrite our index, overwriting removed values + var n0 = values.length; + for (var i = 0, j = 0, oldDataIndex; i < n0; ++i) { + oldDataIndex = index[i]; + if (reIndex[oldDataIndex] !== REMOVED_INDEX) { + if (i !== j) values[j] = values[i]; + index[j] = reIndex[oldDataIndex]; + if (iterable) { + iterablesIndexFilterStatus[j] = iterablesIndexFilterStatus[i]; + } + ++j; + } + } + values.length = j; + if (iterable) iterablesIndexFilterStatus.length = j; + while (j < n0) index[j++] = 0; + + // Bisect again to recompute lo0 and hi0. + var bounds = refilter(values); + lo0 = bounds[0], hi0 = bounds[1]; + } + + // Updates the selected values based on the specified bounds [lo, hi]. + // This implementation is used by all the public filter methods. + function filterIndexBounds(bounds) { + + var lo1 = bounds[0], + hi1 = bounds[1]; + + if (refilterFunction) { + refilterFunction = null; + filterIndexFunction(function(d, i) { return lo1 <= i && i < hi1; }, bounds[0] === 0 && bounds[1] === values.length); + lo0 = lo1; + hi0 = hi1; + return dimension; + } + + var i, + j, + k, + added = [], + removed = [], + valueIndexAdded = [], + valueIndexRemoved = []; + + + // Fast incremental update based on previous lo index. + if (lo1 < lo0) { + for (i = lo1, j = Math.min(lo0, hi1); i < j; ++i) { + added.push(index[i]); + valueIndexAdded.push(i); + } + } else if (lo1 > lo0) { + for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) { + removed.push(index[i]); + valueIndexRemoved.push(i); + } + } + + // Fast incremental update based on previous hi index. + if (hi1 > hi0) { + for (i = Math.max(lo1, hi0), j = hi1; i < j; ++i) { + added.push(index[i]); + valueIndexAdded.push(i); + } + } else if (hi1 < hi0) { + for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) { + removed.push(index[i]); + valueIndexRemoved.push(i); + } + } + + if(!iterable) { + // Flip filters normally. + + for(i=0; i 0) toSkip = top_offset; + + while (--i >= lo0 && k > 0) { + if (filters.zero(j = index[i])) { + if(toSkip > 0) { + //skip matching row + --toSkip; + } else { + array.push(data[j]); + --k; + } + } + } + + if(iterable){ + for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) { + // Add row with empty iterable column at the end + if(filters.zero(j = iterablesEmptyRows[i])) { + if(toSkip > 0) { + //skip matching row + --toSkip; + } else { + array.push(data[j]); + --k; + } + } + } + } + + return array; + } + + // Returns the bottom K selected records based on this dimension's order. + // Note: observes this dimension's filter, unlike group and groupAll. + function bottom(k, bottom_offset) { + var array = [], + i, + j, + toSkip = 0; + + if(bottom_offset && bottom_offset > 0) toSkip = bottom_offset; + + if(iterable) { + // Add row with empty iterable column at the top + for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) { + if(filters.zero(j = iterablesEmptyRows[i])) { + if(toSkip > 0) { + //skip matching row + --toSkip; + } else { + array.push(data[j]); + --k; + } + } + } + } + + i = lo0; + + while (i < hi0 && k > 0) { + if (filters.zero(j = index[i])) { + if(toSkip > 0) { + //skip matching row + --toSkip; + } else { + array.push(data[j]); + --k; + } + } + i++; + } + + return array; + } + + // Adds a new group to this dimension, using the specified key function. + function group(key) { + var group = { + top: top, + all: all, + reduce: reduce, + reduceCount: reduceCount, + reduceSum: reduceSum, + order: order, + orderNatural: orderNatural, + size: size, + dispose: dispose, + remove: dispose // for backwards-compatibility + }; + + // Ensure that this group will be removed when the dimension is removed. + dimensionGroups.push(group); + + var groups, // array of {key, value} + groupIndex, // object id ↦ group id + groupWidth = 8, + groupCapacity = crossfilter_capacity(groupWidth), + k = 0, // cardinality + select, + heap, + reduceAdd, + reduceRemove, + reduceInitial, + update = crossfilter_null, + reset = crossfilter_null, + resetNeeded = true, + groupAll = key === crossfilter_null, + n0old; + + if (arguments.length < 1) key = crossfilter_identity; + + // The group listens to the crossfilter for when any dimension changes, so + // that it can update the associated reduce values. It must also listen to + // the parent dimension for when data is added, and compute new keys. + filterListeners.push(update); + indexListeners.push(add); + removeDataListeners.push(removeData); + + // Incorporate any existing data into the grouping. + add(values, index, 0, n); + + // Incorporates the specified new values into this group. + // This function is responsible for updating groups and groupIndex. + function add(newValues, newIndex, n0, n1) { + + if(iterable) { + n0old = n0 + n0 = values.length - newValues.length + n1 = newValues.length; + } + + var oldGroups = groups, + reIndex = iterable ? [] : crossfilter_index(k, groupCapacity), + add = reduceAdd, + remove = reduceRemove, + initial = reduceInitial, + k0 = k, // old cardinality + i0 = 0, // index of old group + i1 = 0, // index of new record + j, // object id + g0, // old group + x0, // old key + x1, // new key + g, // group to add + x; // key of group to add + + // If a reset is needed, we don't need to update the reduce values. + if (resetNeeded) add = initial = crossfilter_null; + if (resetNeeded) remove = initial = crossfilter_null; + + // Reset the new groups (k is a lower bound). + // Also, make sure that groupIndex exists and is long enough. + groups = new Array(k), k = 0; + if(iterable){ + groupIndex = k0 ? groupIndex : []; + } + else{ + groupIndex = k0 > 1 ? xfilterArray.arrayLengthen(groupIndex, n) : crossfilter_index(n, groupCapacity); + } + + + // Get the first old key (x0 of g0), if it exists. + if (k0) x0 = (g0 = oldGroups[0]).key; + + // Find the first new key (x1), skipping NaN keys. + while (i1 < n1 && !((x1 = key(newValues[i1])) >= x1)) ++i1; + + // While new keys remain… + while (i1 < n1) { + + // Determine the lesser of the two current keys; new and old. + // If there are no old keys remaining, then always add the new key. + if (g0 && x0 <= x1) { + g = g0, x = x0; + + // Record the new index of the old group. + reIndex[i0] = k; + + // Retrieve the next old key. + g0 = oldGroups[++i0]; + if (g0) x0 = g0.key; + } else { + g = {key: x1, value: initial()}, x = x1; + } + + // Add the lesser group. + groups[k] = g; + + // Add any selected records belonging to the added group, while + // advancing the new key and populating the associated group index. + + while (x1 <= x) { + j = newIndex[i1] + (iterable ? n0old : n0) + + + if(iterable){ + if(groupIndex[j]){ + groupIndex[j].push(k) + } + else{ + groupIndex[j] = [k] + } + } + else{ + groupIndex[j] = k; + } + + // Always add new values to groups. Only remove when not in filter. + // This gives groups full information on data life-cycle. + g.value = add(g.value, data[j], true); + if (!filters.zeroExcept(j, offset, zero)) g.value = remove(g.value, data[j], false); + if (++i1 >= n1) break; + x1 = key(newValues[i1]); + } + + groupIncrement(); + } + + // Add any remaining old groups that were greater th1an all new keys. + // No incremental reduce is needed; these groups have no new records. + // Also record the new index of the old group. + while (i0 < k0) { + groups[reIndex[i0] = k] = oldGroups[i0++]; + groupIncrement(); + } + + + // Fill in gaps with empty arrays where there may have been rows with empty iterables + if(iterable){ + for (var index1 = 0; index1 < n; index1++) { + if(!groupIndex[index1]){ + groupIndex[index1] = []; + } + } + } + + // If we added any new groups before any old groups, + // update the group index of all the old records. + if(k > i0){ + if(iterable){ + for (i0 = 0; i0 < n0old; ++i0) { + for (index1 = 0; index1 < groupIndex[i0].length; index1++) { + groupIndex[i0][index1] = reIndex[groupIndex[i0][index1]]; + } + } + } + else{ + for (i0 = 0; i0 < n0; ++i0) { + groupIndex[i0] = reIndex[groupIndex[i0]]; + } + } + } + + // Modify the update and reset behavior based on the cardinality. + // If the cardinality is less than or equal to one, then the groupIndex + // is not needed. If the cardinality is zero, then there are no records + // and therefore no groups to update or reset. Note that we also must + // change the registered listener to point to the new method. + j = filterListeners.indexOf(update); + if (k > 1 || iterable) { + update = updateMany; + reset = resetMany; + } else { + if (!k && groupAll) { + k = 1; + groups = [{key: null, value: initial()}]; + } + if (k === 1) { + update = updateOne; + reset = resetOne; + } else { + update = crossfilter_null; + reset = crossfilter_null; + } + groupIndex = null; + } + filterListeners[j] = update; + + // Count the number of added groups, + // and widen the group index as needed. + function groupIncrement() { + if(iterable){ + k++ + return + } + if (++k === groupCapacity) { + reIndex = xfilterArray.arrayWiden(reIndex, groupWidth <<= 1); + groupIndex = xfilterArray.arrayWiden(groupIndex, groupWidth); + groupCapacity = crossfilter_capacity(groupWidth); + } + } + } + + function removeData(reIndex) { + if (k > 1 || iterable) { + var oldK = k, + oldGroups = groups, + seenGroups = crossfilter_index(oldK, oldK), + i, + i0, + j; + + // Filter out non-matches by copying matching group index entries to + // the beginning of the array. + if (!iterable) { + for (i = 0, j = 0; i < n; ++i) { + if (reIndex[i] !== REMOVED_INDEX) { + seenGroups[groupIndex[j] = groupIndex[i]] = 1; + ++j; + } + } + } else { + for (i = 0, j = 0; i < n; ++i) { + if (reIndex[i] !== REMOVED_INDEX) { + groupIndex[j] = groupIndex[i]; + for (i0 = 0; i0 < groupIndex[j].length; i0++) { + seenGroups[groupIndex[j][i0]] = 1; + } + ++j; + } + } + } + + // Reassemble groups including only those groups that were referred + // to by matching group index entries. Note the new group index in + // seenGroups. + groups = [], k = 0; + for (i = 0; i < oldK; ++i) { + if (seenGroups[i]) { + seenGroups[i] = k++; + groups.push(oldGroups[i]); + } + } + + if (k > 1 || iterable) { + // Reindex the group index using seenGroups to find the new index. + if (!iterable) { + for (i = 0; i < j; ++i) groupIndex[i] = seenGroups[groupIndex[i]]; + } else { + for (i = 0; i < j; ++i) { + for (i0 = 0; i0 < groupIndex[i].length; ++i0) { + groupIndex[i][i0] = seenGroups[groupIndex[i][i0]]; + } + } + } + } else { + groupIndex = null; + } + filterListeners[filterListeners.indexOf(update)] = k > 1 || iterable + ? (reset = resetMany, update = updateMany) + : k === 1 ? (reset = resetOne, update = updateOne) + : reset = update = crossfilter_null; + } else if (k === 1) { + if (groupAll) return; + for (var index3 = 0; index3 < n; ++index3) if (reIndex[index3] !== REMOVED_INDEX) return; + groups = [], k = 0; + filterListeners[filterListeners.indexOf(update)] = + update = reset = crossfilter_null; + } + } + + // Reduces the specified selected or deselected records. + // This function is only used when the cardinality is greater than 1. + // notFilter indicates a crossfilter.add/remove operation. + function updateMany(filterOne, filterOffset, added, removed, notFilter) { + + if ((filterOne === one && filterOffset === offset) || resetNeeded) return; + + var i, + j, + k, + n, + g; + + if(iterable){ + // Add the added values. + for (i = 0, n = added.length; i < n; ++i) { + if (filters.zeroExcept(k = added[i], offset, zero)) { + for (j = 0; j < groupIndex[k].length; j++) { + g = groups[groupIndex[k][j]]; + g.value = reduceAdd(g.value, data[k], false, j); + } + } + } + + // Remove the removed values. + for (i = 0, n = removed.length; i < n; ++i) { + if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) { + for (j = 0; j < groupIndex[k].length; j++) { + g = groups[groupIndex[k][j]]; + g.value = reduceRemove(g.value, data[k], notFilter, j); + } + } + } + return; + } + + // Add the added values. + for (i = 0, n = added.length; i < n; ++i) { + if (filters.zeroExcept(k = added[i], offset, zero)) { + g = groups[groupIndex[k]]; + g.value = reduceAdd(g.value, data[k], false); + } + } + + // Remove the removed values. + for (i = 0, n = removed.length; i < n; ++i) { + if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) { + g = groups[groupIndex[k]]; + g.value = reduceRemove(g.value, data[k], notFilter); + } + } + } + + // Reduces the specified selected or deselected records. + // This function is only used when the cardinality is 1. + // notFilter indicates a crossfilter.add/remove operation. + function updateOne(filterOne, filterOffset, added, removed, notFilter) { + if ((filterOne === one && filterOffset === offset) || resetNeeded) return; + + var i, + k, + n, + g = groups[0]; + + // Add the added values. + for (i = 0, n = added.length; i < n; ++i) { + if (filters.zeroExcept(k = added[i], offset, zero)) { + g.value = reduceAdd(g.value, data[k], false); + } + } + + // Remove the removed values. + for (i = 0, n = removed.length; i < n; ++i) { + if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) { + g.value = reduceRemove(g.value, data[k], notFilter); + } + } + } + + // Recomputes the group reduce values from scratch. + // This function is only used when the cardinality is greater than 1. + function resetMany() { + var i, + j, + g; + + // Reset all group values. + for (i = 0; i < k; ++i) { + groups[i].value = reduceInitial(); + } + + // We add all records and then remove filtered records so that reducers + // can build an 'unfiltered' view even if there are already filters in + // place on other dimensions. + if(iterable){ + for (i = 0; i < n; ++i) { + for (j = 0; j < groupIndex[i].length; j++) { + g = groups[groupIndex[i][j]]; + g.value = reduceAdd(g.value, data[i], true, j); + } + } + for (i = 0; i < n; ++i) { + if (!filters.zeroExcept(i, offset, zero)) { + for (j = 0; j < groupIndex[i].length; j++) { + g = groups[groupIndex[i][j]]; + g.value = reduceRemove(g.value, data[i], false, j); + } + } + } + return; + } + + for (i = 0; i < n; ++i) { + g = groups[groupIndex[i]]; + g.value = reduceAdd(g.value, data[i], true); + } + for (i = 0; i < n; ++i) { + if (!filters.zeroExcept(i, offset, zero)) { + g = groups[groupIndex[i]]; + g.value = reduceRemove(g.value, data[i], false); + } + } + } + + // Recomputes the group reduce values from scratch. + // This function is only used when the cardinality is 1. + function resetOne() { + var i, + g = groups[0]; + + // Reset the singleton group values. + g.value = reduceInitial(); + + // We add all records and then remove filtered records so that reducers + // can build an 'unfiltered' view even if there are already filters in + // place on other dimensions. + for (i = 0; i < n; ++i) { + g.value = reduceAdd(g.value, data[i], true); + } + + for (i = 0; i < n; ++i) { + if (!filters.zeroExcept(i, offset, zero)) { + g.value = reduceRemove(g.value, data[i], false); + } + } + } + + // Returns the array of group values, in the dimension's natural order. + function all() { + if (resetNeeded) reset(), resetNeeded = false; + return groups; + } + + // Returns a new array containing the top K group values, in reduce order. + function top(k) { + var top = select(all(), 0, groups.length, k); + return heap.sort(top, 0, top.length); + } + + // Sets the reduce behavior for this group to use the specified functions. + // This method lazily recomputes the reduce values, waiting until needed. + function reduce(add, remove, initial) { + reduceAdd = add; + reduceRemove = remove; + reduceInitial = initial; + resetNeeded = true; + return group; + } + + // A convenience method for reducing by count. + function reduceCount() { + return reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, crossfilter_zero); + } + + // A convenience method for reducing by sum(value). + function reduceSum(value) { + return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), crossfilter_zero); + } + + // Sets the reduce order, using the specified accessor. + function order(value) { + select = xfilterHeapselect.by(valueOf); + heap = xfilterHeap.by(valueOf); + function valueOf(d) { return value(d.value); } + return group; + } + + // A convenience method for natural ordering by reduce value. + function orderNatural() { + return order(crossfilter_identity); + } + + // Returns the cardinality of this group, irrespective of any filters. + function size() { + return k; + } + + // Removes this group and associated event listeners. + function dispose() { + var i = filterListeners.indexOf(update); + if (i >= 0) filterListeners.splice(i, 1); + i = indexListeners.indexOf(add); + if (i >= 0) indexListeners.splice(i, 1); + i = removeDataListeners.indexOf(removeData); + if (i >= 0) removeDataListeners.splice(i, 1); + return group; + } + + return reduceCount().orderNatural(); + } + + // A convenience function for generating a singleton group. + function groupAll() { + var g = group(crossfilter_null), all = g.all; + delete g.all; + delete g.top; + delete g.order; + delete g.orderNatural; + delete g.size; + g.value = function() { return all()[0].value; }; + return g; + } + + // Removes this dimension and associated groups and event listeners. + function dispose() { + dimensionGroups.forEach(function(group) { group.dispose(); }); + var i = dataListeners.indexOf(preAdd); + if (i >= 0) dataListeners.splice(i, 1); + i = dataListeners.indexOf(postAdd); + if (i >= 0) dataListeners.splice(i, 1); + i = removeDataListeners.indexOf(removeData); + if (i >= 0) removeDataListeners.splice(i, 1); + filters.masks[offset] &= zero; + return filterAll(); + } + + return dimension; + } + + // A convenience method for groupAll on a dummy dimension. + // This implementation can be optimized since it always has cardinality 1. + function groupAll() { + var group = { + reduce: reduce, + reduceCount: reduceCount, + reduceSum: reduceSum, + value: value, + dispose: dispose, + remove: dispose // for backwards-compatibility + }; + + var reduceValue, + reduceAdd, + reduceRemove, + reduceInitial, + resetNeeded = true; + + // The group listens to the crossfilter for when any dimension changes, so + // that it can update the reduce value. It must also listen to the parent + // dimension for when data is added. + filterListeners.push(update); + dataListeners.push(add); + + // For consistency; actually a no-op since resetNeeded is true. + add(data, 0, n); + + // Incorporates the specified new values into this group. + function add(newData, n0) { + var i; + + if (resetNeeded) return; + + // Cycle through all the values. + for (i = n0; i < n; ++i) { + + // Add all values all the time. + reduceValue = reduceAdd(reduceValue, data[i], true); + + // Remove the value if filtered. + if (!filters.zero(i)) { + reduceValue = reduceRemove(reduceValue, data[i], false); + } + } + } + + // Reduces the specified selected or deselected records. + function update(filterOne, filterOffset, added, removed, notFilter) { + var i, + k, + n; + + if (resetNeeded) return; + + // Add the added values. + for (i = 0, n = added.length; i < n; ++i) { + if (filters.zero(k = added[i])) { + reduceValue = reduceAdd(reduceValue, data[k], notFilter); + } + } + + // Remove the removed values. + for (i = 0, n = removed.length; i < n; ++i) { + if (filters.only(k = removed[i], filterOffset, filterOne)) { + reduceValue = reduceRemove(reduceValue, data[k], notFilter); + } + } + } + + // Recomputes the group reduce value from scratch. + function reset() { + var i; + + reduceValue = reduceInitial(); + + // Cycle through all the values. + for (i = 0; i < n; ++i) { + + // Add all values all the time. + reduceValue = reduceAdd(reduceValue, data[i], true); + + // Remove the value if it is filtered. + if (!filters.zero(i)) { + reduceValue = reduceRemove(reduceValue, data[i], false); + } + } + } + + // Sets the reduce behavior for this group to use the specified functions. + // This method lazily recomputes the reduce value, waiting until needed. + function reduce(add, remove, initial) { + reduceAdd = add; + reduceRemove = remove; + reduceInitial = initial; + resetNeeded = true; + return group; + } + + // A convenience method for reducing by count. + function reduceCount() { + return reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, crossfilter_zero); + } + + // A convenience method for reducing by sum(value). + function reduceSum(value) { + return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), crossfilter_zero); + } + + // Returns the computed reduce value. + function value() { + if (resetNeeded) reset(), resetNeeded = false; + return reduceValue; + } + + // Removes this group and associated event listeners. + function dispose() { + var i = filterListeners.indexOf(update); + if (i >= 0) filterListeners.splice(i, 1); + i = dataListeners.indexOf(add); + if (i >= 0) dataListeners.splice(i, 1); + return group; + } + + return reduceCount(); + } + + // Returns the number of records in this crossfilter, irrespective of any filters. + function size() { + return n; + } + + // Returns the raw row data contained in this crossfilter + function all(){ + return data; + } + + // Returns row data with all dimension filters applied + function allFiltered() { + var array = [], + i = 0; + + for (i = 0; i < n; i++) { + if (filters.zero(i)) { + array.push(data[i]); + } + } + + return array; + } + + function onChange(cb){ + if(typeof cb !== 'function'){ + /* eslint no-console: 0 */ + console.warn('onChange callback parameter must be a function!'); + return; + } + callbacks.push(cb); + return function(){ + callbacks.splice(callbacks.indexOf(cb), 1); + }; + } + + function triggerOnChange(eventName){ + for (var i = 0; i < callbacks.length; i++) { + callbacks[i](eventName); + } + } + + return arguments.length + ? add(arguments[0]) + : crossfilter; +} + +// Returns an array of size n, big enough to store ids up to m. +function crossfilter_index(n, m) { + return (m < 0x101 + ? xfilterArray.array8 : m < 0x10001 + ? xfilterArray.array16 + : xfilterArray.array32)(n); +} + +// Constructs a new array of size n, with sequential values from 0 to n - 1. +function crossfilter_range(n) { + var range = crossfilter_index(n, n); + for (var i = -1; ++i < n;) range[i] = i; + return range; +} + +function crossfilter_capacity(w) { + return w === 8 + ? 0x100 : w === 16 + ? 0x10000 + : 0x100000000; +} + +},{"./../package.json":2,"./array":3,"./bisect":4,"./filter":6,"./heap":7,"./heapselect":8,"./identity":9,"./insertionsort":10,"./null":11,"./permute":12,"./quicksort":13,"./reduce":14,"./zero":15,"lodash.result":16}],6:[function(require,module,exports){ +'use strict'; + +function crossfilter_filterExact(bisect, value) { + return function(values) { + var n = values.length; + return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)]; + }; +} + +function crossfilter_filterRange(bisect, range) { + var min = range[0], + max = range[1]; + return function(values) { + var n = values.length; + return [bisect.left(values, min, 0, n), bisect.left(values, max, 0, n)]; + }; +} + +function crossfilter_filterAll(values) { + return [0, values.length]; +} + +module.exports = { + filterExact: crossfilter_filterExact, + filterRange: crossfilter_filterRange, + filterAll: crossfilter_filterAll +}; + +},{}],7:[function(require,module,exports){ +'use strict'; + +var crossfilter_identity = require('./identity'); + +function heap_by(f) { + + // Builds a binary heap within the specified array a[lo:hi]. The heap has the + // property such that the parent a[lo+i] is always less than or equal to its + // two children: a[lo+2*i+1] and a[lo+2*i+2]. + function heap(a, lo, hi) { + var n = hi - lo, + i = (n >>> 1) + 1; + while (--i > 0) sift(a, i, n, lo); + return a; + } + + // Sorts the specified array a[lo:hi] in descending order, assuming it is + // already a heap. + function sort(a, lo, hi) { + var n = hi - lo, + t; + while (--n > 0) t = a[lo], a[lo] = a[lo + n], a[lo + n] = t, sift(a, 1, n, lo); + return a; + } + + // Sifts the element a[lo+i-1] down the heap, where the heap is the contiguous + // slice of array a[lo:lo+n]. This method can also be used to update the heap + // incrementally, without incurring the full cost of reconstructing the heap. + function sift(a, i, n, lo) { + var d = a[--lo + i], + x = f(d), + child; + while ((child = i << 1) <= n) { + if (child < n && f(a[lo + child]) > f(a[lo + child + 1])) child++; + if (x <= f(a[lo + child])) break; + a[lo + i] = a[lo + child]; + i = child; + } + a[lo + i] = d; + } + + heap.sort = sort; + return heap; +} + +module.exports = heap_by(crossfilter_identity); +module.exports.by = heap_by; + +},{"./identity":9}],8:[function(require,module,exports){ +'use strict'; + +var crossfilter_identity = require('./identity'); +var xFilterHeap = require('./heap'); + +function heapselect_by(f) { + var heap = xFilterHeap.by(f); + + // Returns a new array containing the top k elements in the array a[lo:hi]. + // The returned array is not sorted, but maintains the heap property. If k is + // greater than hi - lo, then fewer than k elements will be returned. The + // order of elements in a is unchanged by this operation. + function heapselect(a, lo, hi, k) { + var queue = new Array(k = Math.min(hi - lo, k)), + min, + i, + d; + + for (i = 0; i < k; ++i) queue[i] = a[lo++]; + heap(queue, 0, k); + + if (lo < hi) { + min = f(queue[0]); + do { + if (f(d = a[lo]) > min) { + queue[0] = d; + min = f(heap(queue, 0, k)[0]); + } + } while (++lo < hi); + } + + return queue; + } + + return heapselect; +} + +module.exports = heapselect_by(crossfilter_identity); +module.exports.by = heapselect_by; // assign the raw function to the export as well + +},{"./heap":7,"./identity":9}],9:[function(require,module,exports){ +'use strict'; + +function crossfilter_identity(d) { + return d; +} + +module.exports = crossfilter_identity; + +},{}],10:[function(require,module,exports){ +'use strict'; + +var crossfilter_identity = require('./identity'); + +function insertionsort_by(f) { + + function insertionsort(a, lo, hi) { + for (var i = lo + 1; i < hi; ++i) { + for (var j = i, t = a[i], x = f(t); j > lo && f(a[j - 1]) > x; --j) { + a[j] = a[j - 1]; + } + a[j] = t; + } + return a; + } + + return insertionsort; +} + +module.exports = insertionsort_by(crossfilter_identity); +module.exports.by = insertionsort_by; + +},{"./identity":9}],11:[function(require,module,exports){ +'use strict'; + +function crossfilter_null() { + return null; +} + +module.exports = crossfilter_null; + +},{}],12:[function(require,module,exports){ +'use strict'; + +function permute(array, index, deep) { + for (var i = 0, n = index.length, copy = deep ? JSON.parse(JSON.stringify(array)) : new Array(n); i < n; ++i) { + copy[i] = array[index[i]]; + } + return copy; +} + +module.exports = permute; + +},{}],13:[function(require,module,exports){ +var crossfilter_identity = require('./identity'); +var xFilterInsertionsort = require('./insertionsort'); + +// Algorithm designed by Vladimir Yaroslavskiy. +// Implementation based on the Dart project; see NOTICE and AUTHORS for details. + +function quicksort_by(f) { + var insertionsort = xFilterInsertionsort.by(f); + + function sort(a, lo, hi) { + return (hi - lo < quicksort_sizeThreshold + ? insertionsort + : quicksort)(a, lo, hi); + } + + function quicksort(a, lo, hi) { + // Compute the two pivots by looking at 5 elements. + var sixth = (hi - lo) / 6 | 0, + i1 = lo + sixth, + i5 = hi - 1 - sixth, + i3 = lo + hi - 1 >> 1, // The midpoint. + i2 = i3 - sixth, + i4 = i3 + sixth; + + var e1 = a[i1], x1 = f(e1), + e2 = a[i2], x2 = f(e2), + e3 = a[i3], x3 = f(e3), + e4 = a[i4], x4 = f(e4), + e5 = a[i5], x5 = f(e5); + + var t; + + // Sort the selected 5 elements using a sorting network. + if (x1 > x2) t = e1, e1 = e2, e2 = t, t = x1, x1 = x2, x2 = t; + if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t; + if (x1 > x3) t = e1, e1 = e3, e3 = t, t = x1, x1 = x3, x3 = t; + if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t; + if (x1 > x4) t = e1, e1 = e4, e4 = t, t = x1, x1 = x4, x4 = t; + if (x3 > x4) t = e3, e3 = e4, e4 = t, t = x3, x3 = x4, x4 = t; + if (x2 > x5) t = e2, e2 = e5, e5 = t, t = x2, x2 = x5, x5 = t; + if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t; + if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t; + + var pivot1 = e2, pivotValue1 = x2, + pivot2 = e4, pivotValue2 = x4; + + // e2 and e4 have been saved in the pivot variables. They will be written + // back, once the partitioning is finished. + a[i1] = e1; + a[i2] = a[lo]; + a[i3] = e3; + a[i4] = a[hi - 1]; + a[i5] = e5; + + var less = lo + 1, // First element in the middle partition. + great = hi - 2; // Last element in the middle partition. + + // Note that for value comparison, <, <=, >= and > coerce to a primitive via + // Object.prototype.valueOf; == and === do not, so in order to be consistent + // with natural order (such as for Date objects), we must do two compares. + var pivotsEqual = pivotValue1 <= pivotValue2 && pivotValue1 >= pivotValue2; + if (pivotsEqual) { + + // Degenerated case where the partitioning becomes a dutch national flag + // problem. + // + // [ | < pivot | == pivot | unpartitioned | > pivot | ] + // ^ ^ ^ ^ ^ + // left less k great right + // + // a[left] and a[right] are undefined and are filled after the + // partitioning. + // + // Invariants: + // 1) for x in ]left, less[ : x < pivot. + // 2) for x in [less, k[ : x == pivot. + // 3) for x in ]great, right[ : x > pivot. + for (var k = less; k <= great; ++k) { + var ek = a[k], xk = f(ek); + if (xk < pivotValue1) { + if (k !== less) { + a[k] = a[less]; + a[less] = ek; + } + ++less; + } else if (xk > pivotValue1) { + + // Find the first element <= pivot in the range [k - 1, great] and + // put [:ek:] there. We know that such an element must exist: + // When k == less, then el3 (which is equal to pivot) lies in the + // interval. Otherwise a[k - 1] == pivot and the search stops at k-1. + // Note that in the latter case invariant 2 will be violated for a + // short amount of time. The invariant will be restored when the + // pivots are put into their final positions. + /* eslint no-constant-condition: 0 */ + while (true) { + var greatValue = f(a[great]); + if (greatValue > pivotValue1) { + great--; + // This is the only location in the while-loop where a new + // iteration is started. + continue; + } else if (greatValue < pivotValue1) { + // Triple exchange. + a[k] = a[less]; + a[less++] = a[great]; + a[great--] = ek; + break; + } else { + a[k] = a[great]; + a[great--] = ek; + // Note: if great < k then we will exit the outer loop and fix + // invariant 2 (which we just violated). + break; + } + } + } + } + } else { + + // We partition the list into three parts: + // 1. < pivot1 + // 2. >= pivot1 && <= pivot2 + // 3. > pivot2 + // + // During the loop we have: + // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned | > pivot2 | ] + // ^ ^ ^ ^ ^ + // left less k great right + // + // a[left] and a[right] are undefined and are filled after the + // partitioning. + // + // Invariants: + // 1. for x in ]left, less[ : x < pivot1 + // 2. for x in [less, k[ : pivot1 <= x && x <= pivot2 + // 3. for x in ]great, right[ : x > pivot2 + (function () { // isolate scope + for (var k = less; k <= great; k++) { + var ek = a[k], xk = f(ek); + if (xk < pivotValue1) { + if (k !== less) { + a[k] = a[less]; + a[less] = ek; + } + ++less; + } else { + if (xk > pivotValue2) { + while (true) { + var greatValue = f(a[great]); + if (greatValue > pivotValue2) { + great--; + if (great < k) break; + // This is the only location inside the loop where a new + // iteration is started. + continue; + } else { + // a[great] <= pivot2. + if (greatValue < pivotValue1) { + // Triple exchange. + a[k] = a[less]; + a[less++] = a[great]; + a[great--] = ek; + } else { + // a[great] >= pivot1. + a[k] = a[great]; + a[great--] = ek; + } + break; + } + } + } + } + } + })(); // isolate scope + } + + // Move pivots into their final positions. + // We shrunk the list from both sides (a[left] and a[right] have + // meaningless values in them) and now we move elements from the first + // and third partition into these locations so that we can store the + // pivots. + a[lo] = a[less - 1]; + a[less - 1] = pivot1; + a[hi - 1] = a[great + 1]; + a[great + 1] = pivot2; + + // The list is now partitioned into three partitions: + // [ < pivot1 | >= pivot1 && <= pivot2 | > pivot2 ] + // ^ ^ ^ ^ + // left less great right + + // Recursive descent. (Don't include the pivot values.) + sort(a, lo, less - 1); + sort(a, great + 2, hi); + + if (pivotsEqual) { + // All elements in the second partition are equal to the pivot. No + // need to sort them. + return a; + } + + // In theory it should be enough to call _doSort recursively on the second + // partition. + // The Android source however removes the pivot elements from the recursive + // call if the second partition is too large (more than 2/3 of the list). + if (less < i1 && great > i5) { + + (function () { // isolate scope + var lessValue, greatValue; + while ((lessValue = f(a[less])) <= pivotValue1 && lessValue >= pivotValue1) ++less; + while ((greatValue = f(a[great])) <= pivotValue2 && greatValue >= pivotValue2) --great; + + // Copy paste of the previous 3-way partitioning with adaptions. + // + // We partition the list into three parts: + // 1. == pivot1 + // 2. > pivot1 && < pivot2 + // 3. == pivot2 + // + // During the loop we have: + // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned | == pivot2 ] + // ^ ^ ^ + // less k great + // + // Invariants: + // 1. for x in [ *, less[ : x == pivot1 + // 2. for x in [less, k[ : pivot1 < x && x < pivot2 + // 3. for x in ]great, * ] : x == pivot2 + for (var k = less; k <= great; k++) { + var ek = a[k], xk = f(ek); + if (xk <= pivotValue1 && xk >= pivotValue1) { + if (k !== less) { + a[k] = a[less]; + a[less] = ek; + } + less++; + } else { + if (xk <= pivotValue2 && xk >= pivotValue2) { + /* eslint no-constant-condition: 0 */ + while (true) { + greatValue = f(a[great]); + if (greatValue <= pivotValue2 && greatValue >= pivotValue2) { + great--; + if (great < k) break; + // This is the only location inside the loop where a new + // iteration is started. + continue; + } else { + // a[great] < pivot2. + if (greatValue < pivotValue1) { + // Triple exchange. + a[k] = a[less]; + a[less++] = a[great]; + a[great--] = ek; + } else { + // a[great] == pivot1. + a[k] = a[great]; + a[great--] = ek; + } + break; + } + } + } + } + } + })(); // isolate scope + + } + + // The second partition has now been cleared of pivot elements and looks + // as follows: + // [ * | > pivot1 && < pivot2 | * ] + // ^ ^ + // less great + // Sort the second partition using recursive descent. + + // The second partition looks as follows: + // [ * | >= pivot1 && <= pivot2 | * ] + // ^ ^ + // less great + // Simply sort it by recursive descent. + + return sort(a, less, great + 1); + } + + return sort; +} + +var quicksort_sizeThreshold = 32; + +module.exports = quicksort_by(crossfilter_identity); +module.exports.by = quicksort_by; + +},{"./identity":9,"./insertionsort":10}],14:[function(require,module,exports){ +'use strict'; + +function crossfilter_reduceIncrement(p) { + return p + 1; +} + +function crossfilter_reduceDecrement(p) { + return p - 1; +} + +function crossfilter_reduceAdd(f) { + return function(p, v) { + return p + +f(v); + }; +} + +function crossfilter_reduceSubtract(f) { + return function(p, v) { + return p - f(v); + }; +} + +module.exports = { + reduceIncrement: crossfilter_reduceIncrement, + reduceDecrement: crossfilter_reduceDecrement, + reduceAdd: crossfilter_reduceAdd, + reduceSubtract: crossfilter_reduceSubtract +}; + +},{}],15:[function(require,module,exports){ +'use strict'; + +function crossfilter_zero() { + return 0; +} + +module.exports = crossfilter_zero; + +},{}],16:[function(require,module,exports){ +(function (global){ +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** `Object#toString` result references. */ +var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + symbolTag = '[object Symbol]'; + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + reLeadingDot = /^\./, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ +function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var Symbol = root.Symbol, + splice = arrayProto.splice; + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'), + nativeCreate = getNative(Object, 'create'); + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value) { + return isArray(value) ? value : stringToPath(value); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoize(function(string) { + string = toString(string); + + var result = []; + if (reLeadingDot.test(string)) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result); + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} + +// Assign cache to `_.memoize`. +memoize.Cache = MapCache; + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ +function toString(value) { + return value == null ? '' : baseToString(value); +} + +/** + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */ +function result(object, path, defaultValue) { + path = isKey(path, object) ? [path] : castPath(path); + + var index = -1, + length = path.length; + + // Ensure the loop is entered when path is empty. + if (!length) { + object = undefined; + length = 1; + } + while (++index < length) { + var value = object == null ? undefined : object[toKey(path[index])]; + if (value === undefined) { + index = length; + value = defaultValue; + } + object = isFunction(value) ? value.call(object) : value; + } + return object; +} + +module.exports = result; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],17:[function(require,module,exports){ +var reductio_parameters = require('./parameters.js'); + +_assign = function assign(target) { + if (target == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + + var output = Object(target); + for (var index = 1; index < arguments.length; ++index) { + var source = arguments[index]; + if (source != null) { + for (var nextKey in source) { + if(source.hasOwnProperty(nextKey)) { + output[nextKey] = source[nextKey]; + } + } + } + } + return output; +}; + +function accessor_build(obj, p) { + // obj.order = function(value) { + // if (!arguments.length) return p.order; + // p.order = value; + // return obj; + // }; + + // Converts a string to an accessor function + function accessorify(v) { + if( typeof v === 'string' ) { + // Rewrite to a function + var tempValue = v; + var func = function (d) { return d[tempValue]; } + return func; + } else { + return v; + } + } + + // Converts a string to an accessor function + function accessorifyNumeric(v) { + if( typeof v === 'string' ) { + // Rewrite to a function + var tempValue = v; + var func = function (d) { return +d[tempValue]; } + return func; + } else { + return v; + } + } + + obj.fromObject = function(value) { + if(!arguments.length) return p; + _assign(p, value); + return obj; + }; + + obj.toObject = function() { + return p; + }; + + obj.count = function(value, propName) { + if (!arguments.length) return p.count; + if (!propName) { + propName = 'count'; + } + p.count = propName; + return obj; + }; + + obj.sum = function(value) { + if (!arguments.length) return p.sum; + + value = accessorifyNumeric(value); + + p.sum = value; + return obj; + }; + + obj.avg = function(value) { + if (!arguments.length) return p.avg; + + value = accessorifyNumeric(value); + + // We can take an accessor function, a boolean, or a string + if( typeof value === 'function' ) { + if(p.sum && p.sum !== value) console.warn('SUM aggregation is being overwritten by AVG aggregation'); + p.sum = value; + p.avg = true; + p.count = 'count'; + } else { + p.avg = value; + } + return obj; + }; + + obj.exception = function(value) { + if (!arguments.length) return p.exceptionAccessor; + + value = accessorify(value); + + p.exceptionAccessor = value; + return obj; + }; + + obj.filter = function(value) { + if (!arguments.length) return p.filter; + p.filter = value; + return obj; + }; + + obj.valueList = function(value) { + if (!arguments.length) return p.valueList; + + value = accessorify(value); + + p.valueList = value; + return obj; + }; + + obj.median = function(value) { + if (!arguments.length) return p.median; + + value = accessorifyNumeric(value); + + if(typeof value === 'function') { + if(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by median aggregation'); + p.valueList = value; + } + p.median = value; + return obj; + }; + + obj.min = function(value) { + if (!arguments.length) return p.min; + + value = accessorifyNumeric(value); + + if(typeof value === 'function') { + if(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by min aggregation'); + p.valueList = value; + } + p.min = value; + return obj; + }; + + obj.max = function(value) { + if (!arguments.length) return p.max; + + value = accessorifyNumeric(value); + + if(typeof value === 'function') { + if(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by max aggregation'); + p.valueList = value; + } + p.max = value; + return obj; + }; + + obj.exceptionCount = function(value) { + if (!arguments.length) return p.exceptionCount; + + value = accessorify(value); + + if( typeof value === 'function' ) { + if(p.exceptionAccessor && p.exceptionAccessor !== value) console.warn('EXCEPTION accessor is being overwritten by exception count aggregation'); + p.exceptionAccessor = value; + p.exceptionCount = true; + } else { + p.exceptionCount = value; + } + return obj; + }; + + obj.exceptionSum = function(value) { + if (!arguments.length) return p.exceptionSum; + + value = accessorifyNumeric(value); + + p.exceptionSum = value; + return obj; + }; + + obj.histogramValue = function(value) { + if (!arguments.length) return p.histogramValue; + + value = accessorifyNumeric(value); + + p.histogramValue = value; + return obj; + }; + + obj.histogramBins = function(value) { + if (!arguments.length) return p.histogramThresholds; + p.histogramThresholds = value; + return obj; + }; + + obj.std = function(value) { + if (!arguments.length) return p.std; + + value = accessorifyNumeric(value); + + if(typeof(value) === 'function') { + p.sumOfSquares = value; + p.sum = value; + p.count = 'count'; + p.std = true; + } else { + p.std = value; + } + return obj; + }; + + obj.sumOfSq = function(value) { + if (!arguments.length) return p.sumOfSquares; + + value = accessorifyNumeric(value); + + p.sumOfSquares = value; + return obj; + }; + + obj.value = function(value, accessor) { + if (!arguments.length || typeof value !== 'string' ) { + console.error("'value' requires a string argument."); + } else { + if(!p.values) p.values = {}; + p.values[value] = {}; + p.values[value].parameters = reductio_parameters(); + accessor_build(p.values[value], p.values[value].parameters); + if(accessor) p.values[value].accessor = accessor; + return p.values[value]; + } + }; + + obj.nest = function(keyAccessorArray) { + if(!arguments.length) return p.nestKeys; + + keyAccessorArray.map(accessorify); + + p.nestKeys = keyAccessorArray; + return obj; + }; + + obj.alias = function(propAccessorObj) { + if(!arguments.length) return p.aliasKeys; + p.aliasKeys = propAccessorObj; + return obj; + }; + + obj.aliasProp = function(propAccessorObj) { + if(!arguments.length) return p.aliasPropKeys; + p.aliasPropKeys = propAccessorObj; + return obj; + }; + + obj.groupAll = function(groupTest) { + if(!arguments.length) return p.groupAll; + p.groupAll = groupTest; + return obj; + }; + + obj.dataList = function(value) { + if (!arguments.length) return p.dataList; + p.dataList = value; + return obj; + }; + + obj.custom = function(addRemoveInitialObj) { + if (!arguments.length) return p.custom; + p.custom = addRemoveInitialObj; + return obj; + }; + +} + +var reductio_accessors = { + build: accessor_build +}; + +module.exports = reductio_accessors; + +},{"./parameters.js":34}],18:[function(require,module,exports){ +var reductio_alias = { + initial: function(prior, path, obj) { + return function (p) { + if(prior) p = prior(p); + function buildAliasFunction(key){ + return function(){ + return obj[key](path(p)); + }; + } + for(var prop in obj) { + path(p)[prop] = buildAliasFunction(prop); + } + return p; + }; + } +}; + +module.exports = reductio_alias; +},{}],19:[function(require,module,exports){ +var reductio_alias_prop = { + add: function (obj, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + for(var prop in obj) { + path(p)[prop] = obj[prop](path(p),v); + } + return p; + }; + } +}; + +module.exports = reductio_alias_prop; +},{}],20:[function(require,module,exports){ +var reductio_avg = { + add: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + if(path(p).count > 0) { + path(p).avg = path(p).sum / path(p).count; + } else { + path(p).avg = 0; + } + return p; + }; + }, + remove: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + if(path(p).count > 0) { + path(p).avg = path(p).sum / path(p).count; + } else { + path(p).avg = 0; + } + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).avg = 0; + return p; + }; + } +}; + +module.exports = reductio_avg; +},{}],21:[function(require,module,exports){ +var reductio_filter = require('./filter.js'); +var reductio_count = require('./count.js'); +var reductio_sum = require('./sum.js'); +var reductio_avg = require('./avg.js'); +var reductio_median = require('./median.js'); +var reductio_min = require('./min.js'); +var reductio_max = require('./max.js'); +var reductio_value_count = require('./value-count.js'); +var reductio_value_list = require('./value-list.js'); +var reductio_exception_count = require('./exception-count.js'); +var reductio_exception_sum = require('./exception-sum.js'); +var reductio_histogram = require('./histogram.js'); +var reductio_sum_of_sq = require('./sum-of-squares.js'); +var reductio_std = require('./std.js'); +var reductio_nest = require('./nest.js'); +var reductio_alias = require('./alias.js'); +var reductio_alias_prop = require('./aliasProp.js'); +var reductio_data_list = require('./data-list.js'); +var reductio_custom = require('./custom.js'); + +function build_function(p, f, path) { + // We have to build these functions in order. Eventually we can include dependency + // information and create a dependency graph if the process becomes complex enough. + + if(!path) path = function (d) { return d; }; + + // Keep track of the original reducers so that filtering can skip back to + // them if this particular value is filtered out. + var origF = { + reduceAdd: f.reduceAdd, + reduceRemove: f.reduceRemove, + reduceInitial: f.reduceInitial + }; + + if(p.count || p.std) { + f.reduceAdd = reductio_count.add(f.reduceAdd, path, p.count); + f.reduceRemove = reductio_count.remove(f.reduceRemove, path, p.count); + f.reduceInitial = reductio_count.initial(f.reduceInitial, path, p.count); + } + + if(p.sum) { + f.reduceAdd = reductio_sum.add(p.sum, f.reduceAdd, path); + f.reduceRemove = reductio_sum.remove(p.sum, f.reduceRemove, path); + f.reduceInitial = reductio_sum.initial(f.reduceInitial, path); + } + + if(p.avg) { + if(!p.count || !p.sum) { + console.error("You must set .count(true) and define a .sum(accessor) to use .avg(true)."); + } else { + f.reduceAdd = reductio_avg.add(p.sum, f.reduceAdd, path); + f.reduceRemove = reductio_avg.remove(p.sum, f.reduceRemove, path); + f.reduceInitial = reductio_avg.initial(f.reduceInitial, path); + } + } + + // The unique-only reducers come before the value_count reducers. They need to check if + // the value is already in the values array on the group. They should only increment/decrement + // counts if the value not in the array or the count on the value is 0. + if(p.exceptionCount) { + if(!p.exceptionAccessor) { + console.error("You must define an .exception(accessor) to use .exceptionCount(true)."); + } else { + f.reduceAdd = reductio_exception_count.add(p.exceptionAccessor, f.reduceAdd, path); + f.reduceRemove = reductio_exception_count.remove(p.exceptionAccessor, f.reduceRemove, path); + f.reduceInitial = reductio_exception_count.initial(f.reduceInitial, path); + } + } + + if(p.exceptionSum) { + if(!p.exceptionAccessor) { + console.error("You must define an .exception(accessor) to use .exceptionSum(accessor)."); + } else { + f.reduceAdd = reductio_exception_sum.add(p.exceptionAccessor, p.exceptionSum, f.reduceAdd, path); + f.reduceRemove = reductio_exception_sum.remove(p.exceptionAccessor, p.exceptionSum, f.reduceRemove, path); + f.reduceInitial = reductio_exception_sum.initial(f.reduceInitial, path); + } + } + + // Maintain the values array. + if(p.valueList || p.median || p.min || p.max) { + f.reduceAdd = reductio_value_list.add(p.valueList, f.reduceAdd, path); + f.reduceRemove = reductio_value_list.remove(p.valueList, f.reduceRemove, path); + f.reduceInitial = reductio_value_list.initial(f.reduceInitial, path); + } + + // Maintain the data array. + if(p.dataList) { + f.reduceAdd = reductio_data_list.add(p.dataList, f.reduceAdd, path); + f.reduceRemove = reductio_data_list.remove(p.dataList, f.reduceRemove, path); + f.reduceInitial = reductio_data_list.initial(f.reduceInitial, path); + } + + if(p.median) { + f.reduceAdd = reductio_median.add(f.reduceAdd, path); + f.reduceRemove = reductio_median.remove(f.reduceRemove, path); + f.reduceInitial = reductio_median.initial(f.reduceInitial, path); + } + + if(p.min) { + f.reduceAdd = reductio_min.add(f.reduceAdd, path); + f.reduceRemove = reductio_min.remove(f.reduceRemove, path); + f.reduceInitial = reductio_min.initial(f.reduceInitial, path); + } + + if(p.max) { + f.reduceAdd = reductio_max.add(f.reduceAdd, path); + f.reduceRemove = reductio_max.remove(f.reduceRemove, path); + f.reduceInitial = reductio_max.initial(f.reduceInitial, path); + } + + // Maintain the values count array. + if(p.exceptionAccessor) { + f.reduceAdd = reductio_value_count.add(p.exceptionAccessor, f.reduceAdd, path); + f.reduceRemove = reductio_value_count.remove(p.exceptionAccessor, f.reduceRemove, path); + f.reduceInitial = reductio_value_count.initial(f.reduceInitial, path); + } + + // Histogram + if(p.histogramValue && p.histogramThresholds) { + f.reduceAdd = reductio_histogram.add(p.histogramValue, f.reduceAdd, path); + f.reduceRemove = reductio_histogram.remove(p.histogramValue, f.reduceRemove, path); + f.reduceInitial = reductio_histogram.initial(p.histogramThresholds ,f.reduceInitial, path); + } + + // Sum of Squares + if(p.sumOfSquares) { + f.reduceAdd = reductio_sum_of_sq.add(p.sumOfSquares, f.reduceAdd, path); + f.reduceRemove = reductio_sum_of_sq.remove(p.sumOfSquares, f.reduceRemove, path); + f.reduceInitial = reductio_sum_of_sq.initial(f.reduceInitial, path); + } + + // Standard deviation + if(p.std) { + if(!p.sumOfSquares || !p.sum) { + console.error("You must set .sumOfSq(accessor) and define a .sum(accessor) to use .std(true). Or use .std(accessor)."); + } else { + f.reduceAdd = reductio_std.add(f.reduceAdd, path); + f.reduceRemove = reductio_std.remove(f.reduceRemove, path); + f.reduceInitial = reductio_std.initial(f.reduceInitial, path); + } + } + + // Custom reducer defined by 3 functions : add, remove, initial + if (p.custom) { + f.reduceAdd = reductio_custom.add(f.reduceAdd, path, p.custom.add); + f.reduceRemove = reductio_custom.remove(f.reduceRemove, path, p.custom.remove); + f.reduceInitial = reductio_custom.initial(f.reduceInitial, path, p.custom.initial); + } + + // Nesting + if(p.nestKeys) { + f.reduceAdd = reductio_nest.add(p.nestKeys, f.reduceAdd, path); + f.reduceRemove = reductio_nest.remove(p.nestKeys, f.reduceRemove, path); + f.reduceInitial = reductio_nest.initial(f.reduceInitial, path); + } + + // Alias functions + if(p.aliasKeys) { + f.reduceInitial = reductio_alias.initial(f.reduceInitial, path, p.aliasKeys); + } + + // Alias properties - this is less efficient than alias functions + if(p.aliasPropKeys) { + f.reduceAdd = reductio_alias_prop.add(p.aliasPropKeys, f.reduceAdd, path); + // This isn't a typo. The function is the same for add/remove. + f.reduceRemove = reductio_alias_prop.add(p.aliasPropKeys, f.reduceRemove, path); + } + + // Filters determine if our built-up priors should run, or if it should skip + // back to the filters given at the beginning of this build function. + if (p.filter) { + f.reduceAdd = reductio_filter.add(p.filter, f.reduceAdd, origF.reduceAdd, path); + f.reduceRemove = reductio_filter.remove(p.filter, f.reduceRemove, origF.reduceRemove, path); + } + + // Values go last. + if(p.values) { + Object.getOwnPropertyNames(p.values).forEach(function(n) { + // Set up the path on each group. + var setupPath = function(prior) { + return function (p) { + p = prior(p); + path(p)[n] = {}; + return p; + }; + }; + f.reduceInitial = setupPath(f.reduceInitial); + build_function(p.values[n].parameters, f, function (p) { return p[n]; }); + }); + } +} + +var reductio_build = { + build: build_function +}; + +module.exports = reductio_build; + +},{"./alias.js":18,"./aliasProp.js":19,"./avg.js":20,"./count.js":23,"./custom.js":24,"./data-list.js":25,"./exception-count.js":26,"./exception-sum.js":27,"./filter.js":28,"./histogram.js":29,"./max.js":30,"./median.js":31,"./min.js":32,"./nest.js":33,"./std.js":39,"./sum-of-squares.js":40,"./sum.js":41,"./value-count.js":42,"./value-list.js":43}],22:[function(require,module,exports){ +var pluck = function(n){ + return function(d){ + return d[n]; + }; +}; + +// supported operators are sum, avg, and count +_grouper = function(path, prior){ + if(!path) path = function(d){return d;}; + return function(p, v){ + if(prior) prior(p, v); + var x = path(p), y = path(v); + if(typeof y.count !== 'undefined') x.count += y.count; + if(typeof y.sum !== 'undefined') x.sum += y.sum; + if(typeof y.avg !== 'undefined') x.avg = x.sum/x.count; + return p; + }; +}; + +reductio_cap = function (prior, f, p) { + var obj = f.reduceInitial(); + // we want to support values so we'll need to know what those are + var values = p.values ? Object.keys(p.values) : []; + var _othersGrouper = _grouper(); + if (values.length) { + for (var i = 0; i < values.length; ++i) { + _othersGrouper = _grouper(pluck(values[i]), _othersGrouper); + } + } + return function (cap, othersName) { + if (!arguments.length) return prior(); + if( cap === Infinity || !cap ) return prior(); + var all = prior(); + var slice_idx = cap-1; + if(all.length <= cap) return all; + var data = all.slice(0, slice_idx); + var others = {key: othersName || 'Others'}; + others.value = f.reduceInitial(); + for (var i = slice_idx; i < all.length; ++i) { + _othersGrouper(others.value, all[i].value); + } + data.push(others); + return data; + }; +}; + +module.exports = reductio_cap; + +},{}],23:[function(require,module,exports){ +var reductio_count = { + add: function(prior, path, propName) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p)[propName]++; + return p; + }; + }, + remove: function(prior, path, propName) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p)[propName]--; + return p; + }; + }, + initial: function(prior, path, propName) { + return function (p) { + if(prior) p = prior(p); + // if(p === undefined) p = {}; + path(p)[propName] = 0; + return p; + }; + } +}; + +module.exports = reductio_count; +},{}],24:[function(require,module,exports){ +var reductio_custom = { + add: function(prior, path, addFn) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + return addFn(p, v); + }; + }, + remove: function(prior, path, removeFn) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + return removeFn(p, v); + }; + }, + initial: function(prior, path, initialFn) { + return function (p) { + if(prior) p = prior(p); + return initialFn(p); + }; + } +}; + +module.exports = reductio_custom; +},{}],25:[function(require,module,exports){ +var reductio_data_list = { + add: function(a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).dataList.push(v); + return p; + }; + }, + remove: function(a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).dataList.splice(path(p).dataList.indexOf(v), 1); + return p; + }; + }, + initial: function(prior, path) { + return function (p) { + if(prior) p = prior(p); + path(p).dataList = []; + return p; + }; + } +}; + +module.exports = reductio_data_list; + +},{}],26:[function(require,module,exports){ +var reductio_exception_count = { + add: function (a, prior, path) { + var i, curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Only count++ if the p.values array doesn't contain a(v) or if it's 0. + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + curr = path(p).values[i]; + if((!curr || curr[0] !== a(v)) || curr[1] === 0) { + path(p).exceptionCount++; + } + return p; + }; + }, + remove: function (a, prior, path) { + var i, curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Only count-- if the p.values array contains a(v) value of 1. + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + curr = path(p).values[i]; + if(curr && curr[0] === a(v) && curr[1] === 1) { + path(p).exceptionCount--; + } + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).exceptionCount = 0; + return p; + }; + } +}; + +module.exports = reductio_exception_count; +},{}],27:[function(require,module,exports){ +var reductio_exception_sum = { + add: function (a, sum, prior, path) { + var i, curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Only sum if the p.values array doesn't contain a(v) or if it's 0. + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + curr = path(p).values[i]; + if((!curr || curr[0] !== a(v)) || curr[1] === 0) { + path(p).exceptionSum = path(p).exceptionSum + sum(v); + } + return p; + }; + }, + remove: function (a, sum, prior, path) { + var i, curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Only sum if the p.values array contains a(v) value of 1. + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + curr = path(p).values[i]; + if(curr && curr[0] === a(v) && curr[1] === 1) { + path(p).exceptionSum = path(p).exceptionSum - sum(v); + } + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).exceptionSum = 0; + return p; + }; + } +}; + +module.exports = reductio_exception_sum; +},{}],28:[function(require,module,exports){ +var reductio_filter = { + // The big idea here is that you give us a filter function to run on values, + // a 'prior' reducer to run (just like the rest of the standard reducers), + // and a reference to the last reducer (called 'skip' below) defined before + // the most recent chain of reducers. This supports individual filters for + // each .value('...') chain that you add to your reducer. + add: function (filter, prior, skip) { + return function (p, v, nf) { + if (filter(v, nf)) { + if (prior) prior(p, v, nf); + } else { + if (skip) skip(p, v, nf); + } + return p; + }; + }, + remove: function (filter, prior, skip) { + return function (p, v, nf) { + if (filter(v, nf)) { + if (prior) prior(p, v, nf); + } else { + if (skip) skip(p, v, nf); + } + return p; + }; + } +}; + +module.exports = reductio_filter; + +},{}],29:[function(require,module,exports){ +var crossfilter = require('crossfilter2'); + +var reductio_histogram = { + add: function (a, prior, path) { + var bisect = crossfilter.bisect.by(function(d) { return d; }).left; + var bisectHisto = crossfilter.bisect.by(function(d) { return d.x; }).right; + var curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + curr = path(p).histogram[bisectHisto(path(p).histogram, a(v), 0, path(p).histogram.length) - 1]; + curr.y++; + curr.splice(bisect(curr, a(v), 0, curr.length), 0, a(v)); + return p; + }; + }, + remove: function (a, prior, path) { + var bisect = crossfilter.bisect.by(function(d) { return d; }).left; + var bisectHisto = crossfilter.bisect.by(function(d) { return d.x; }).right; + var curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + curr = path(p).histogram[bisectHisto(path(p).histogram, a(v), 0, path(p).histogram.length) - 1]; + curr.y--; + curr.splice(bisect(curr, a(v), 0, curr.length), 1); + return p; + }; + }, + initial: function (thresholds, prior, path) { + return function (p) { + p = prior(p); + path(p).histogram = []; + var arr = []; + for(var i = 1; i < thresholds.length; i++) { + arr = []; + arr.x = thresholds[i - 1]; + arr.dx = (thresholds[i] - thresholds[i - 1]); + arr.y = 0; + path(p).histogram.push(arr); + } + return p; + }; + } +}; + +module.exports = reductio_histogram; +},{"crossfilter2":1}],30:[function(require,module,exports){ +var reductio_max = { + add: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + path(p).max = path(p).valueList[path(p).valueList.length - 1]; + + return p; + }; + }, + remove: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + // Check for undefined. + if(path(p).valueList.length === 0) { + path(p).max = undefined; + return p; + } + + path(p).max = path(p).valueList[path(p).valueList.length - 1]; + + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).max = undefined; + return p; + }; + } +}; + +module.exports = reductio_max; +},{}],31:[function(require,module,exports){ +var reductio_median = { + add: function (prior, path) { + var half; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + half = Math.floor(path(p).valueList.length/2); + + if(path(p).valueList.length % 2) { + path(p).median = path(p).valueList[half]; + } else { + path(p).median = (path(p).valueList[half-1] + path(p).valueList[half]) / 2.0; + } + + return p; + }; + }, + remove: function (prior, path) { + var half; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + half = Math.floor(path(p).valueList.length/2); + + // Check for undefined. + if(path(p).valueList.length === 0) { + path(p).median = undefined; + return p; + } + + if(path(p).valueList.length === 1 || path(p).valueList.length % 2) { + path(p).median = path(p).valueList[half]; + } else { + path(p).median = (path(p).valueList[half-1] + path(p).valueList[half]) / 2.0; + } + + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).median = undefined; + return p; + }; + } +}; + +module.exports = reductio_median; +},{}],32:[function(require,module,exports){ +var reductio_min = { + add: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + path(p).min = path(p).valueList[0]; + + return p; + }; + }, + remove: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + // Check for undefined. + if(path(p).valueList.length === 0) { + path(p).min = undefined; + return p; + } + + path(p).min = path(p).valueList[0]; + + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).min = undefined; + return p; + }; + } +}; + +module.exports = reductio_min; +},{}],33:[function(require,module,exports){ +var crossfilter = require('crossfilter2'); + +var reductio_nest = { + add: function (keyAccessors, prior, path) { + var i; // Current key accessor + var arrRef; + var newRef; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + arrRef = path(p).nest; + keyAccessors.forEach(function(a) { + newRef = arrRef.filter(function(d) { return d.key === a(v); })[0]; + if(newRef) { + // There is another level. + arrRef = newRef.values; + } else { + // Next level doesn't yet exist so we create it. + newRef = []; + arrRef.push({ key: a(v), values: newRef }); + arrRef = newRef; + } + }); + + arrRef.push(v); + + return p; + }; + }, + remove: function (keyAccessors, prior, path) { + var arrRef; + var nextRef; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + + arrRef = path(p).nest; + keyAccessors.forEach(function(a) { + arrRef = arrRef.filter(function(d) { return d.key === a(v); })[0].values; + }); + + // Array contains an actual reference to the row, so just splice it out. + arrRef.splice(arrRef.indexOf(v), 1); + + // If the leaf now has length 0 and it's not the base array remove it. + // TODO + + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).nest = []; + return p; + }; + } +}; + +module.exports = reductio_nest; +},{"crossfilter2":1}],34:[function(require,module,exports){ +var reductio_parameters = function() { + return { + order: false, + avg: false, + count: false, + sum: false, + exceptionAccessor: false, + exceptionCount: false, + exceptionSum: false, + filter: false, + valueList: false, + median: false, + histogramValue: false, + min: false, + max: false, + histogramThresholds: false, + std: false, + sumOfSquares: false, + values: false, + nestKeys: false, + aliasKeys: false, + aliasPropKeys: false, + groupAll: false, + dataList: false, + custom: false + }; +}; + +module.exports = reductio_parameters; + +},{}],35:[function(require,module,exports){ +function postProcess(reductio) { + return function (group, p, f) { + group.post = function(){ + var postprocess = function () { + return postprocess.all(); + }; + postprocess.all = function () { + return group.all(); + }; + var postprocessors = reductio.postprocessors; + Object.keys(postprocessors).forEach(function (name) { + postprocess[name] = function () { + var _all = postprocess.all; + var args = [].slice.call(arguments); + postprocess.all = function () { + return postprocessors[name](_all, f, p).apply(null, args); + }; + return postprocess; + }; + }); + return postprocess; + }; + }; +} + +module.exports = postProcess; + +},{}],36:[function(require,module,exports){ +module.exports = function(reductio){ + reductio.postprocessors = {}; + reductio.registerPostProcessor = function(name, func){ + reductio.postprocessors[name] = func; + }; + + reductio.registerPostProcessor('cap', require('./cap')); + reductio.registerPostProcessor('sortBy', require('./sortBy')); +}; + +},{"./cap":22,"./sortBy":38}],37:[function(require,module,exports){ +var reductio_build = require('./build.js'); +var reductio_accessors = require('./accessors.js'); +var reductio_parameters = require('./parameters.js'); +var reductio_postprocess = require('./postprocess'); +var crossfilter = require('crossfilter2'); + +function reductio() { + var parameters = reductio_parameters(); + + var funcs = {}; + + function my(group) { + // Start fresh each time. + funcs = { + reduceAdd: function(p) { return p; }, + reduceRemove: function(p) { return p; }, + reduceInitial: function () { return {}; }, + }; + + reductio_build.build(parameters, funcs); + + // If we're doing groupAll + if(parameters.groupAll) { + if(group.top) { + console.warn("'groupAll' is defined but attempting to run on a standard dimension.group(). Must run on dimension.groupAll()."); + } else { + var bisect = crossfilter.bisect.by(function(d) { return d.key; }).left; + var i, j; + var keys; + var keysLength; + var k; // Key + group.reduce( + function(p, v, nf) { + keys = parameters.groupAll(v); + keysLength = keys.length; + for(j=0;j b ? 1 : a >= b ? 0 : NaN; +} + +var comparer = function (accessor, ordering) { + return function (a, b) { + return ordering(accessor(a), accessor(b)); + }; +}; + +var type = {}.toString; + +module.exports = function (prior) { + return function (value, order) { + if (arguments.length === 1) { + order = ascending; + } + return prior().sort(comparer(pluck_n(value), order)); + }; +}; + +},{}],39:[function(require,module,exports){ +var reductio_std = { + add: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + if(path(p).count > 0) { + path(p).std = 0.0; + var n = path(p).sumOfSq - path(p).sum*path(p).sum/path(p).count; + if (n>0.0) path(p).std = Math.sqrt(n/(path(p).count-1)); + } else { + path(p).std = 0.0; + } + return p; + }; + }, + remove: function (prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + if(path(p).count > 0) { + path(p).std = 0.0; + var n = path(p).sumOfSq - path(p).sum*path(p).sum/path(p).count; + if (n>0.0) path(p).std = Math.sqrt(n/(path(p).count-1)); + } else { + path(p).std = 0; + } + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).std = 0; + return p; + }; + } +}; + +module.exports = reductio_std; +},{}],40:[function(require,module,exports){ +var reductio_sum_of_sq = { + add: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).sumOfSq = path(p).sumOfSq + a(v)*a(v); + return p; + }; + }, + remove: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).sumOfSq = path(p).sumOfSq - a(v)*a(v); + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).sumOfSq = 0; + return p; + }; + } +}; + +module.exports = reductio_sum_of_sq; +},{}],41:[function(require,module,exports){ +var reductio_sum = { + add: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).sum = path(p).sum + a(v); + return p; + }; + }, + remove: function (a, prior, path) { + return function (p, v, nf) { + if(prior) prior(p, v, nf); + path(p).sum = path(p).sum - a(v); + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).sum = 0; + return p; + }; + } +}; + +module.exports = reductio_sum; +},{}],42:[function(require,module,exports){ +var crossfilter = require('crossfilter2'); + +var reductio_value_count = { + add: function (a, prior, path) { + var i, curr; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Not sure if this is more efficient than sorting. + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + curr = path(p).values[i]; + if(curr && curr[0] === a(v)) { + // Value already exists in the array - increment it + curr[1]++; + } else { + // Value doesn't exist - add it in form [value, 1] + path(p).values.splice(i, 0, [a(v), 1]); + } + return p; + }; + }, + remove: function (a, prior, path) { + var i; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + i = path(p).bisect(path(p).values, a(v), 0, path(p).values.length); + // Value already exists or something has gone terribly wrong. + path(p).values[i][1]--; + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + // Array[Array[value, count]] + path(p).values = []; + path(p).bisect = crossfilter.bisect.by(function(d) { return d[0]; }).left; + return p; + }; + } +}; + +module.exports = reductio_value_count; +},{"crossfilter2":1}],43:[function(require,module,exports){ +var crossfilter = require('crossfilter2'); + +var reductio_value_list = { + add: function (a, prior, path) { + var i; + var bisect = crossfilter.bisect.by(function(d) { return d; }).left; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + // Not sure if this is more efficient than sorting. + i = bisect(path(p).valueList, a(v), 0, path(p).valueList.length); + path(p).valueList.splice(i, 0, a(v)); + return p; + }; + }, + remove: function (a, prior, path) { + var i; + var bisect = crossfilter.bisect.by(function(d) { return d; }).left; + return function (p, v, nf) { + if(prior) prior(p, v, nf); + i = bisect(path(p).valueList, a(v), 0, path(p).valueList.length); + // Value already exists or something has gone terribly wrong. + path(p).valueList.splice(i, 1); + return p; + }; + }, + initial: function (prior, path) { + return function (p) { + p = prior(p); + path(p).valueList = []; + return p; + }; + } +}; + +module.exports = reductio_value_list; +},{"crossfilter2":1}],44:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +var aggregators = { + // Collections + $sum: $sum, + $avg: $avg, + $max: $max, + $min: $min, + + // Pickers + $count: $count, + $first: $first, + $last: $last, + $get: $get, + $nth: $get, // nth is same as using a get + $nthLast: $nthLast, + $nthPct: $nthPct, + $map: $map, +} + +module.exports = { + makeValueAccessor: makeValueAccessor, + aggregators: aggregators, + extractKeyValOrArray: extractKeyValOrArray, + parseAggregatorParams: parseAggregatorParams, +} +// This is used to build aggregation stacks for sub-reductio +// aggregations, or plucking values for use in filters from the data +function makeValueAccessor(obj) { + if (typeof obj === 'string') { + if (isStringSyntax(obj)) { + obj = convertAggregatorString(obj) + } else { + // Must be a column key. Return an identity accessor + return obj + } + } + // Must be a column index. Return an identity accessor + if (typeof obj === 'number') { + return obj + } + // If it's an object, we need to build a custom value accessor function + if (_.isObject(obj)) { + return make() + } + + function make() { + var stack = makeSubAggregationFunction(obj) + return function topStack(d) { + return stack(d) + } + } +} + +// A recursive function that walks the aggregation stack and returns +// a function. The returned function, when called, will recursively invoke +// with the properties from the previous stack in reverse order +function makeSubAggregationFunction(obj) { + // If its an object, either unwrap all of the properties as an + // array of keyValues, or unwrap the first keyValue set as an object + obj = _.isObject(obj) ? extractKeyValOrArray(obj) : obj + + // Detect strings + if (_.isString(obj)) { + // If begins with a $, then we need to convert it over to a regular query object and analyze it again + if (isStringSyntax(obj)) { + return makeSubAggregationFunction(convertAggregatorString(obj)) + } + // If normal string, then just return a an itentity accessor + return function identity(d) { + return d[obj] + } + } + + // If an array, recurse into each item and return as a map + if (_.isArray(obj)) { + var subStack = _.map(obj, makeSubAggregationFunction) + return function getSubStack(d) { + return subStack.map(function(s) { + return s(d) + }) + } + } + + // If object, find the aggregation, and recurse into the value + if (obj.key) { + if (aggregators[obj.key]) { + var subAggregationFunction = makeSubAggregationFunction(obj.value) + return function getAggregation(d) { + return aggregators[obj.key](subAggregationFunction(d)) + } + } + console.error('Could not find aggregration method', obj) + } + + return [] +} + +function extractKeyValOrArray(obj) { + var keyVal + var values = [] + for (var key in obj) { + if ({}.hasOwnProperty.call(obj, key)) { + keyVal = { + key: key, + value: obj[key], + } + var subObj = {} + subObj[key] = obj[key] + values.push(subObj) + } + } + return values.length > 1 ? values : keyVal +} + +function isStringSyntax(str) { + return ['$', '('].indexOf(str.charAt(0)) > -1 +} + +function parseAggregatorParams(keyString) { + var params = [] + var p1 = keyString.indexOf('(') + var p2 = keyString.indexOf(')') + var key = p1 > -1 ? keyString.substring(0, p1) : keyString + if (!aggregators[key]) { + return false + } + if (p1 > -1 && p2 > -1 && p2 > p1) { + params = keyString.substring(p1 + 1, p2).split(',') + } + + return { + aggregator: aggregators[key], + params: params, + } +} + +function convertAggregatorString(keyString) { + // var obj = {} // obj is defined but not used + + // 1. unwrap top parentheses + // 2. detect arrays + + // parentheses + var outerParens = /\((.+)\)/g + // var innerParens = /\(([^\(\)]+)\)/g // innerParens is defined but not used + // comma not in () + var hasComma = /(?:\([^\(\)]*\))|(,)/g + + return JSON.parse('{' + unwrapParensAndCommas(keyString) + '}') + + function unwrapParensAndCommas(str) { + str = str.replace(' ', '') + return ( + '"' + + str.replace(outerParens, function(p, pr) { + if (hasComma.test(pr)) { + if (pr.charAt(0) === '$') { + return ( + '":{"' + + pr.replace(hasComma, function(p2 /* , pr2 */) { + if (p2 === ',') { + return ',"' + } + return unwrapParensAndCommas(p2).trim() + }) + + '}' + ) + } + return ( + ':["' + + pr.replace( + hasComma, + function(/* p2 , pr2 */) { + return '","' + } + ) + + '"]' + ) + } + }) + ) + } +} + +// Collection Aggregators + +function $sum(children) { + return children.reduce(function(a, b) { + return a + b + }, 0) +} + +function $avg(children) { + return ( + children.reduce(function(a, b) { + return a + b + }, 0) / children.length + ) +} + +function $max(children) { + return Math.max.apply(null, children) +} + +function $min(children) { + return Math.min.apply(null, children) +} + +function $count(children) { + return children.length +} + +/* function $med(children) { // $med is defined but not used + children.sort(function(a, b) { + return a - b + }) + var half = Math.floor(children.length / 2) + if (children.length % 2) + return children[half] + else + return (children[half - 1] + children[half]) / 2.0 +} */ + +function $first(children) { + return children[0] +} + +function $last(children) { + return children[children.length - 1] +} + +function $get(children, n) { + return children[n] +} + +function $nthLast(children, n) { + return children[children.length - n] +} + +function $nthPct(children, n) { + return children[Math.round(children.length * (n / 100))] +} + +function $map(children, n) { + return children.map(function(d) { + return d[n] + }) +} + +},{"./lodash":52}],45:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +module.exports = function(service) { + return function clear(def) { + // Clear a single or multiple column definitions + if (def) { + def = _.isArray(def) ? def : [def] + } + + if (!def) { + // Clear all of the column defenitions + return Promise.all( + _.map(service.columns, disposeColumn) + ).then(function() { + service.columns = [] + return service + }) + } + + return Promise.all( + _.map(def, function(d) { + if (_.isObject(d)) { + d = d.key + } + // Clear the column + var column = _.remove(service.columns, function(c) { + if (_.isArray(d)) { + return !_.xor(c.key, d).length + } + if (c.key === d) { + if (c.dynamicReference) { + return false + } + return true + } + })[0] + + if (!column) { + // console.info('Attempted to clear a column that is required for another query!', c) + return + } + + disposeColumn(column) + }) + ).then(function() { + return service + }) + + function disposeColumn(column) { + var disposalActions = [] + // Dispose the dimension + if (column.removeListeners) { + disposalActions = _.map(column.removeListeners, function(listener) { + return Promise.resolve(listener()) + }) + } + var filterKey = column.key + if (column.complex === 'array') { + filterKey = JSON.stringify(column.key) + } + if (column.complex === 'function') { + filterKey = column.key.toString() + } + delete service.filters[filterKey] + if (column.dimension) { + disposalActions.push(Promise.resolve(column.dimension.dispose())) + } + return Promise.all(disposalActions) + } + } +} + +},{"./lodash":52}],46:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +module.exports = function (service) { + var dimension = require('./dimension')(service) + + var columnFunc = column + columnFunc.find = findColumn + + return columnFunc + + function column(def) { + // Support groupAll dimension + if (_.isUndefined(def)) { + def = true + } + + // Always deal in bulk. Like Costco! + if (!_.isArray(def)) { + def = [def] + } + + // Mapp all column creation, wait for all to settle, then return the instance + return Promise.all(_.map(def, makeColumn)) + .then(function () { + return service + }) + } + + function findColumn(d) { + return _.find(service.columns, function (c) { + if (_.isArray(d)) { + return !_.xor(c.key, d).length + } + return c.key === d + }) + } + + function getType(d) { + if (_.isNumber(d)) { + return 'number' + } + if (_.isBoolean(d)) { + return 'bool' + } + if (_.isArray(d)) { + return 'array' + } + if (_.isObject(d)) { + return 'object' + } + return 'string' + } + + function makeColumn(d) { + var column = _.isObject(d) ? d : { + key: d, + } + + var existing = findColumn(column.key) + + if (existing) { + existing.temporary = false + if (existing.dynamicReference) { + existing.dynamicReference = false + } + return existing.promise + .then(function () { + return service + }) + } + + // for storing info about queries and post aggregations + column.queries = [] + service.columns.push(column) + + column.promise = new Promise(function (resolve, reject) { + try { + resolve(service.cf.all()) + } catch (err) { + reject(err) + } + }) + .then(function (all) { + var sample + + // Complex column Keys + if (_.isFunction(column.key)) { + column.complex = 'function' + sample = column.key(all[0]) + } else if (_.isString(column.key) && (column.key.indexOf('.') > -1 || column.key.indexOf('[') > -1)) { + column.complex = 'string' + sample = _.get(all[0], column.key) + } else if (_.isArray(column.key)) { + column.complex = 'array' + sample = _.values(_.pick(all[0], column.key)) + if (sample.length !== column.key.length) { + throw new Error('Column key does not exist in data!', column.key) + } + } else { + sample = all[0][column.key] + } + + // Index Column + if (!column.complex && column.key !== true && typeof sample === 'undefined') { + throw new Error('Column key does not exist in data!', column.key) + } + + // If the column exists, let's at least make sure it's marked + // as permanent. There is a slight chance it exists because + // of a filter, and the user decides to make it permanent + + if (column.key === true) { + column.type = 'all' + } else if (column.complex) { + column.type = 'complex' + } else if (column.array) { + column.type = 'array' + } else { + column.type = getType(sample) + } + + return dimension.make(column.key, column.type, column.complex) + }) + .then(function (dim) { + column.dimension = dim + column.filterCount = 0 + var stopListeningForData = service.onDataChange(buildColumnKeys) + column.removeListeners = [stopListeningForData] + + return buildColumnKeys() + + // Build the columnKeys + function buildColumnKeys(changes) { + if (column.key === true) { + return Promise.resolve() + } + + var accessor = dimension.makeAccessor(column.key, column.complex) + column.values = column.values || [] + + return new Promise(function (resolve, reject) { + try { + if (changes && changes.added) { + resolve(changes.added) + } else { + resolve(column.dimension.bottom(Infinity)) + } + } catch (err) { + reject(err) + } + }) + .then(function (rows) { + var newValues + if (column.complex === 'string' || column.complex === 'function') { + newValues = _.map(rows, accessor) + // console.log(rows, accessor.toString(), newValues) + } else if (column.type === 'array') { + newValues = _.flatten(_.map(rows, accessor)) + } else { + newValues = _.map(rows, accessor) + } + column.values = _.uniq(column.values.concat(newValues)) + }) + } + }) + + return column.promise + .then(function () { + return service + }) + } +} + +},{"./dimension":49,"./lodash":52}],47:[function(require,module,exports){ +'use strict' + +var crossfilter = require('crossfilter2') + +var _ = require('./lodash') + +module.exports = function (service) { + return { + build: build, + generateColumns: generateColumns, + add: add, + remove: remove, + } + + function build(c) { + if (_.isArray(c)) { + // This allows support for crossfilter async + return Promise.resolve(crossfilter(c)) + } + if (!c || typeof c.dimension !== 'function') { + return Promise.reject(new Error('No Crossfilter data or instance found!')) + } + return Promise.resolve(c) + } + + function generateColumns(data) { + if (!service.options.generatedColumns) { + return data + } + return _.map(data, function (d/* , i */) { + _.forEach(service.options.generatedColumns, function (val, key) { + d[key] = val(d) + }) + return d + }) + } + + function add(data) { + data = generateColumns(data) + return new Promise(function (resolve, reject) { + try { + resolve(service.cf.add(data)) + } catch (err) { + reject(err) + } + }) + .then(function () { + return _.map(service.dataListeners, function (listener) { + return function () { + return listener({ + added: data, + }) + } + }).reduce(function(promise, data) { + return promise.then(data) + }, Promise.resolve(true)) + }) + + .then(function() { + return Promise.all(_.map(service.filterListeners, function (listener) { + return listener() + })) + }) + + .then(function () { + return service + }) + } + + function remove(predicate) { + return new Promise(function (resolve, reject) { + try { + resolve(service.cf.remove(predicate)) + } catch (err) { + reject(err) + } + }) + + .then(function() { + return Promise.all(_.map(service.filterListeners, function (listener) { + return listener() + })) + }) + + .then(function () { + return service + }) + } +} + + + +},{"./lodash":52,"crossfilter2":1}],48:[function(require,module,exports){ +'use strict' + +// var _ = require('./lodash') // _ is defined but never used + +module.exports = function (service) { + return function destroy() { + return service.clear() + .then(function () { + service.cf.dataListeners = [] + service.cf.filterListeners = [] + return Promise.resolve(service.cf.remove()) + }) + .then(function () { + return service + }) + } +} + +},{}],49:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +module.exports = function (service) { + return { + make: make, + makeAccessor: makeAccessor, + } + + function make(key, type, complex) { + var accessor = makeAccessor(key, complex) + // Promise.resolve will handle promises or non promises, so + // this crossfilter async is supported if present + return Promise.resolve(service.cf.dimension(accessor, type === 'array')) + } + + function makeAccessor(key, complex) { + var accessorFunction + + if (complex === 'string') { + accessorFunction = function (d) { + return _.get(d, key) + } + } else if (complex === 'function') { + accessorFunction = key + } else if (complex === 'array') { + var arrayString = _.map(key, function (k) { + return 'd[\'' + k + '\']' + }) + accessorFunction = new Function('d', String('return ' + JSON.stringify(arrayString).replace(/"/g, ''))) // eslint-disable-line no-new-func + } else { + accessorFunction = + // Index Dimension + key === true ? function accessor(d, i) { + return i + } : + // Value Accessor Dimension + function (d) { + return d[key] + } + } + return accessorFunction + } +} + +},{"./lodash":52}],50:[function(require,module,exports){ +'use strict' + +// var moment = require('moment') + +module.exports = { + // Getters + $field: $field, + // Booleans + $and: $and, + $or: $or, + $not: $not, + + // Expressions + $eq: $eq, + $gt: $gt, + $gte: $gte, + $lt: $lt, + $lte: $lte, + $ne: $ne, + $type: $type, + + // Array Expressions + $in: $in, + $nin: $nin, + $contains: $contains, + $excludes: $excludes, + $size: $size, +} + +// Getters +function $field(d, child) { + return d[child] +} + +// Operators + +function $and(d, child) { + child = child(d) + for (var i = 0; i < child.length; i++) { + if (!child[i]) { + return false + } + } + return true +} + +function $or(d, child) { + child = child(d) + for (var i = 0; i < child.length; i++) { + if (child[i]) { + return true + } + } + return false +} + +function $not(d, child) { + child = child(d) + for (var i = 0; i < child.length; i++) { + if (child[i]) { + return false + } + } + return true +} + +// Expressions + +function $eq(d, child) { + return d === child() +} + +function $gt(d, child) { + return d > child() +} + +function $gte(d, child) { + return d >= child() +} + +function $lt(d, child) { + return d < child() +} + +function $lte(d, child) { + return d <= child() +} + +function $ne(d, child) { + return d !== child() +} + +function $type(d, child) { + return typeof d === child() +} + +// Array Expressions + +function $in(d, child) { + return d.indexOf(child()) > -1 +} + +function $nin(d, child) { + return d.indexOf(child()) === -1 +} + +function $contains(d, child) { + return child().indexOf(d) > -1 +} + +function $excludes(d, child) { + return child().indexOf(d) === -1 +} + +function $size(d, child) { + return d.length === child() +} + +},{}],51:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +var expressions = require('./expressions') +var aggregation = require('./aggregation') + +module.exports = function (service) { + return { + filter: filter, + filterAll: filterAll, + applyFilters: applyFilters, + makeFunction: makeFunction, + scanForDynamicFilters: scanForDynamicFilters, + } + + function filter(column, fil, isRange, replace) { + return getColumn(column) + .then(function (column) { + // Clone a copy of the new filters + var newFilters = _.assign({}, service.filters) + // Here we use the registered column key despite the filter key passed, just in case the filter key's ordering is ordered differently :) + var filterKey = column.key + if (column.complex === 'array') { + filterKey = JSON.stringify(column.key) + } + if (column.complex === 'function') { + filterKey = column.key.toString() + } + // Build the filter object + newFilters[filterKey] = buildFilterObject(fil, isRange, replace) + + return applyFilters(newFilters) + }) + } + + function getColumn(column) { + var exists = service.column.find(column) + // If the filters dimension doesn't exist yet, try and create it + return new Promise(function (resolve, reject) { + try { + if (!exists) { + return resolve(service.column({ + key: column, + temporary: true, + }) + .then(function () { + // It was able to be created, so retrieve and return it + return service.column.find(column) + }) + ) + } else { + // It exists, so just return what we found + resolve(exists) + } + } catch (err) { + reject(err) + } + }) + } + + function filterAll(fils) { + // If empty, remove all filters + if (!fils) { + service.columns.forEach(function (col) { + col.dimension.filterAll() + }) + return applyFilters({}) + } + + // Clone a copy for the new filters + var newFilters = _.assign({}, service.filters) + + var ds = _.map(fils, function (fil) { + return getColumn(fil.column) + .then(function (column) { + // Here we use the registered column key despite the filter key passed, just in case the filter key's ordering is ordered differently :) + var filterKey = column.complex ? JSON.stringify(column.key) : column.key + // Build the filter object + newFilters[filterKey] = buildFilterObject(fil.value, fil.isRange, fil.replace) + }) + }) + + return Promise.all(ds) + .then(function () { + return applyFilters(newFilters) + }) + } + + function buildFilterObject(fil, isRange, replace) { + if (_.isUndefined(fil)) { + return false + } + if (_.isFunction(fil)) { + return { + value: fil, + function: fil, + replace: true, + type: 'function', + } + } + if (_.isObject(fil)) { + return { + value: fil, + function: makeFunction(fil), + replace: true, + type: 'function', + } + } + if (_.isArray(fil)) { + return { + value: fil, + replace: isRange || replace, + type: isRange ? 'range' : 'inclusive', + } + } + return { + value: fil, + replace: replace, + type: 'exact', + } + } + + function applyFilters(newFilters) { + var ds = _.map(newFilters, function (fil, i) { + var existing = service.filters[i] + // Filters are the same, so no change is needed on this column + if (fil === existing) { + return Promise.resolve() + } + var column + // Retrieve complex columns by decoding the column key as json + if (i.charAt(0) === '[') { + column = service.column.find(JSON.parse(i)) + } else { + // Retrieve the column normally + column = service.column.find(i) + } + + // Toggling a filter value is a bit different from replacing them + if (fil && existing && !fil.replace) { + newFilters[i] = fil = toggleFilters(fil, existing) + } + + // If no filter, remove everything from the dimension + if (!fil) { + return Promise.resolve(column.dimension.filterAll()) + } + if (fil.type === 'exact') { + return Promise.resolve(column.dimension.filterExact(fil.value)) + } + if (fil.type === 'range') { + return Promise.resolve(column.dimension.filterRange(fil.value)) + } + if (fil.type === 'inclusive') { + return Promise.resolve(column.dimension.filterFunction(function (d) { + return fil.value.indexOf(d) > -1 + })) + } + if (fil.type === 'function') { + return Promise.resolve(column.dimension.filterFunction(fil.function)) + } + // By default if something craps up, just remove all filters + return Promise.resolve(column.dimension.filterAll()) + }) + + return Promise.all(ds) + .then(function () { + // Save the new filters satate + service.filters = newFilters + + // Pluck and remove falsey filters from the mix + var tryRemoval = [] + _.forEach(service.filters, function (val, key) { + if (!val) { + tryRemoval.push({ + key: key, + val: val, + }) + delete service.filters[key] + } + }) + + // If any of those filters are the last dependency for the column, then remove the column + return Promise.all(_.map(tryRemoval, function (v) { + var column = service.column.find((v.key.charAt(0) === '[') ? JSON.parse(v.key) : v.key) + if (column.temporary && !column.dynamicReference) { + return service.clear(column.key) + } + })) + }) + .then(function () { + // Call the filterListeners and wait for their return + return Promise.all(_.map(service.filterListeners, function (listener) { + return listener() + })) + }) + .then(function () { + return service + }) + } + + function toggleFilters(fil, existing) { + // Exact from Inclusive + if (fil.type === 'exact' && existing.type === 'inclusive') { + fil.value = _.xor([fil.value], existing.value) + } else if (fil.type === 'inclusive' && existing.type === 'exact') { // Inclusive from Exact + fil.value = _.xor(fil.value, [existing.value]) + } else if (fil.type === 'inclusive' && existing.type === 'inclusive') { // Inclusive / Inclusive Merge + fil.value = _.xor(fil.value, existing.value) + } else if (fil.type === 'exact' && existing.type === 'exact') { // Exact / Exact + // If the values are the same, remove the filter entirely + if (fil.value === existing.value) { + return false + } + // They they are different, make an array + fil.value = [fil.value, existing.value] + } + + // Set the new type based on the merged values + if (!fil.value.length) { + fil = false + } else if (fil.value.length === 1) { + fil.type = 'exact' + fil.value = fil.value[0] + } else { + fil.type = 'inclusive' + } + + return fil + } + + function scanForDynamicFilters(query) { + // Here we check to see if there are any relative references to the raw data + // being used in the filter. If so, we need to build those dimensions and keep + // them updated so the filters can be rebuilt if needed + // The supported keys right now are: $column, $data + var columns = [] + walk(query.filter) + return columns + + function walk(obj) { + _.forEach(obj, function (val, key) { + // find the data references, if any + var ref = findDataReferences(val, key) + if (ref) { + columns.push(ref) + } + // if it's a string + if (_.isString(val)) { + ref = findDataReferences(null, val) + if (ref) { + columns.push(ref) + } + } + // If it's another object, keep looking + if (_.isObject(val)) { + walk(val) + } + }) + } + } + + function findDataReferences(val, key) { + // look for the $data string as a value + if (key === '$data') { + return true + } + + // look for the $column key and it's value as a string + if (key && key === '$column') { + if (_.isString(val)) { + return val + } + console.warn('The value for filter "$column" must be a valid column key', val) + return false + } + } + + function makeFunction(obj, isAggregation) { + var subGetters + + // Detect raw $data reference + if (_.isString(obj)) { + var dataRef = findDataReferences(null, obj) + if (dataRef) { + var data = service.cf.all() + return function () { + return data + } + } + } + + if (_.isString(obj) || _.isNumber(obj) || _.isBoolean(obj)) { + return function (d) { + if (typeof d === 'undefined') { + return obj + } + return expressions.$eq(d, function () { + return obj + }) + } + } + + // If an array, recurse into each item and return as a map + if (_.isArray(obj)) { + subGetters = _.map(obj, function (o) { + return makeFunction(o, isAggregation) + }) + return function (d) { + return subGetters.map(function (s) { + return s(d) + }) + } + } + + // If object, return a recursion function that itself, returns the results of all of the object keys + if (_.isObject(obj)) { + subGetters = _.map(obj, function (val, key) { + // Get the child + var getSub = makeFunction(val, isAggregation) + + // Detect raw $column references + var dataRef = findDataReferences(val, key) + if (dataRef) { + var column = service.column.find(dataRef) + var data = column.values + return function () { + return data + } + } + + // If expression, pass the parentValue and the subGetter + if (expressions[key]) { + return function (d) { + return expressions[key](d, getSub) + } + } + + var aggregatorObj = aggregation.parseAggregatorParams(key) + if (aggregatorObj) { + // Make sure that any further operations are for aggregations + // and not filters + isAggregation = true + // here we pass true to makeFunction which denotes that + // an aggregatino chain has started and to stop using $AND + getSub = makeFunction(val, isAggregation) + // If it's an aggregation object, be sure to pass in the children, and then any additional params passed into the aggregation string + return function () { + return aggregatorObj.aggregator.apply(null, [getSub()].concat(aggregatorObj.params)) + } + } + + // It must be a string then. Pluck that string key from parent, and pass it as the new value to the subGetter + return function (d) { + d = d[key] + return getSub(d, getSub) + } + }) + + // All object expressions are basically AND's + // Return AND with a map of the subGetters + if (isAggregation) { + if (subGetters.length === 1) { + return function (d) { + return subGetters[0](d) + } + } + return function (d) { + return _.map(subGetters, function (getSub) { + return getSub(d) + }) + } + } + return function (d) { + return expressions.$and(d, function (d) { + return _.map(subGetters, function (getSub) { + return getSub(d) + }) + }) + } + } + + console.log('no expression found for ', obj) + return false + } +} + +},{"./aggregation":44,"./expressions":50,"./lodash":52}],52:[function(require,module,exports){ +/* eslint no-prototype-builtins: 0 */ +'use strict' + +module.exports = { + assign: assign, + find: find, + remove: remove, + isArray: isArray, + isObject: isObject, + isBoolean: isBoolean, + isString: isString, + isNumber: isNumber, + isFunction: isFunction, + get: get, + set: set, + map: map, + keys: keys, + sortBy: sortBy, + forEach: forEach, + isUndefined: isUndefined, + pick: pick, + xor: xor, + clone: clone, + isEqual: isEqual, + replaceArray: replaceArray, + uniq: uniq, + flatten: flatten, + sort: sort, + values: values, + recurseObject: recurseObject, +} + +function assign(out) { + out = out || {} + for (var i = 1; i < arguments.length; i++) { + if (!arguments[i]) { + continue + } + for (var key in arguments[i]) { + if (arguments[i].hasOwnProperty(key)) { + out[key] = arguments[i][key] + } + } + } + return out +} + +function find(a, b) { + return a.find(b) +} + +function remove(a, b) { + return a.filter(function (o, i) { + var r = b(o) + if (r) { + a.splice(i, 1) + return true + } + return false + }) +} + +function isArray(a) { + return Array.isArray(a) +} + +function isObject(d) { + return typeof d === 'object' && !isArray(d) +} + +function isBoolean(d) { + return typeof d === 'boolean' +} + +function isString(d) { + return typeof d === 'string' +} + +function isNumber(d) { + return typeof d === 'number' +} + +function isFunction(a) { + return typeof a === 'function' +} + +function get(a, b) { + if (isArray(b)) { + b = b.join('.') + } + return b + .replace('[', '.').replace(']', '') + .split('.') + .reduce( + function (obj, property) { + return obj[property] + }, a + ) +} + +function set(obj, prop, value) { + if (typeof prop === 'string') { + prop = prop + .replace('[', '.').replace(']', '') + .split('.') + } + if (prop.length > 1) { + var e = prop.shift() + assign(obj[e] = + Object.prototype.toString.call(obj[e]) === '[object Object]' ? obj[e] : {}, + prop, + value) + } else { + obj[prop[0]] = value + } +} + +function map(a, b) { + var m + var key + if (isFunction(b)) { + if (isObject(a)) { + m = [] + for (key in a) { + if (a.hasOwnProperty(key)) { + m.push(b(a[key], key, a)) + } + } + return m + } + return a.map(b) + } + if (isObject(a)) { + m = [] + for (key in a) { + if (a.hasOwnProperty(key)) { + m.push(a[key]) + } + } + return m + } + return a.map(function (aa) { + return aa[b] + }) +} + +function keys(obj) { + return Object.keys(obj) +} + +function sortBy(a, b) { + if (isFunction(b)) { + return a.sort(function (aa, bb) { + if (b(aa) > b(bb)) { + return 1 + } + if (b(aa) < b(bb)) { + return -1 + } + // a must be equal to b + return 0 + }) + } +} + +function forEach(a, b) { + if (isObject(a)) { + for (var key in a) { + if (a.hasOwnProperty(key)) { + b(a[key], key, a) + } + } + return + } + if (isArray(a)) { + return a.forEach(b) + } +} + +function isUndefined(a) { + return typeof a === 'undefined' +} + +function pick(a, b) { + var c = {} + forEach(b, function (bb) { + if (typeof a[bb] !== 'undefined') { + c[bb] = a[bb] + } + }) + return c +} + +function xor(a, b) { + var unique = [] + forEach(a, function (aa) { + if (b.indexOf(aa) === -1) { + return unique.push(aa) + } + }) + forEach(b, function (bb) { + if (a.indexOf(bb) === -1) { + return unique.push(bb) + } + }) + return unique +} + +function clone(a) { + return JSON.parse(JSON.stringify(a, function replacer(key, value) { + if (typeof value === 'function') { + return value.toString() + } + return value + })) +} + +function isEqual(x, y) { + if ((typeof x === 'object' && x !== null) && (typeof y === 'object' && y !== null)) { + if (Object.keys(x).length !== Object.keys(y).length) { + return false + } + + for (var prop in x) { + if (y.hasOwnProperty(prop)) { + if (!isEqual(x[prop], y[prop])) { + return false + } + } + return false + } + + return true + } else if (x !== y) { + return false + } + return true +} + +function replaceArray(a, b) { + var al = a.length + var bl = b.length + if (al > bl) { + a.splice(bl, al - bl) + } else if (al < bl) { + a.push.apply(a, new Array(bl - al)) + } + forEach(a, function (val, key) { + a[key] = b[key] + }) + return a +} + +function uniq(a) { + var seen = new Set() + return a.filter(function (item) { + var allow = false + if (!seen.has(item)) { + seen.add(item) + allow = true + } + return allow + }) +} + +function flatten(aa) { + var flattened = [] + for (var i = 0; i < aa.length; ++i) { + var current = aa[i] + for (var j = 0; j < current.length; ++j) { + flattened.push(current[j]) + } + } + return flattened +} + +function sort(arr) { + for (var i = 1; i < arr.length; i++) { + var tmp = arr[i] + var j = i + while (arr[j - 1] > tmp) { + arr[j] = arr[j - 1] + --j + } + arr[j] = tmp + } + + return arr +} + +function values(a) { + var values = [] + for (var key in a) { + if (a.hasOwnProperty(key)) { + values.push(a[key]) + } + } + return values +} + +function recurseObject(obj, cb) { + _recurseObject(obj, []) + return obj + function _recurseObject(obj, path) { + for (var k in obj) { // eslint-disable-line guard-for-in + var newPath = clone(path) + newPath.push(k) + if (typeof obj[k] === 'object' && obj[k] !== null) { + _recurseObject(obj[k], newPath) + } else { + if (!obj.hasOwnProperty(k)) { + continue + } + cb(obj[k], k, newPath) + } + } + } +} + +},{}],53:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +var aggregation = require('./aggregation') + +module.exports = function (/* service */) { + return { + post: post, + sortByKey: sortByKey, + limit: limit, + squash: squash, + change: change, + changeMap: changeMap, + } + + function post(query, parent, cb) { + query.data = cloneIfLocked(parent) + return Promise.resolve(cb(query, parent)) + } + + function sortByKey(query, parent, desc) { + query.data = cloneIfLocked(parent) + query.data = _.sortBy(query.data, function (d) { + return d.key + }) + if (desc) { + query.data.reverse() + } + } + + // Limit results to n, or from start to end + function limit(query, parent, start, end) { + query.data = cloneIfLocked(parent) + if (_.isUndefined(end)) { + end = start || 0 + start = 0 + } else { + start = start || 0 + end = end || query.data.length + } + query.data = query.data.splice(start, end - start) + } + + // Squash results to n, or from start to end + function squash(query, parent, start, end, aggObj, label) { + query.data = cloneIfLocked(parent) + start = start || 0 + end = end || query.data.length + var toSquash = query.data.splice(start, end - start) + var squashed = { + key: label || 'Other', + value: {}, + } + _.recurseObject(aggObj, function (val, key, path) { + var items = [] + _.forEach(toSquash, function (record) { + items.push(_.get(record.value, path)) + }) + _.set(squashed.value, path, aggregation.aggregators[val](items)) + }) + query.data.splice(start, 0, squashed) + } + + function change(query, parent, start, end, aggObj) { + query.data = cloneIfLocked(parent) + start = start || 0 + end = end || query.data.length + var obj = { + key: [query.data[start].key, query.data[end].key], + value: {}, + } + _.recurseObject(aggObj, function (val, key, path) { + var changePath = _.clone(path) + changePath.pop() + changePath.push(key + 'Change') + _.set(obj.value, changePath, _.get(query.data[end].value, path) - _.get(query.data[start].value, path)) + }) + query.data = obj + } + + function changeMap(query, parent, aggObj, defaultNull) { + defaultNull = _.isUndefined(defaultNull) ? 0 : defaultNull + query.data = cloneIfLocked(parent) + _.recurseObject(aggObj, function (val, key, path) { + var changePath = _.clone(path) + var fromStartPath = _.clone(path) + var fromEndPath = _.clone(path) + + changePath.pop() + fromStartPath.pop() + fromEndPath.pop() + + changePath.push(key + 'Change') + fromStartPath.push(key + 'ChangeFromStart') + fromEndPath.push(key + 'ChangeFromEnd') + + var start = _.get(query.data[0].value, path, defaultNull) + var end = _.get(query.data[query.data.length - 1].value, path, defaultNull) + + _.forEach(query.data, function (record, i) { + var previous = query.data[i - 1] || query.data[0] + _.set(query.data[i].value, changePath, _.get(record.value, path, defaultNull) - (previous ? _.get(previous.value, path, defaultNull) : defaultNull)) + _.set(query.data[i].value, fromStartPath, _.get(record.value, path, defaultNull) - start) + _.set(query.data[i].value, fromEndPath, _.get(record.value, path, defaultNull) - end) + }) + }) + } +} + +function cloneIfLocked(parent) { + return parent.locked ? _.clone(parent.data) : parent.data +} + +},{"./aggregation":44,"./lodash":52}],54:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +module.exports = function (service) { + var reductiofy = require('./reductiofy')(service) + var filters = require('./filters')(service) + var postAggregation = require('./postAggregation')(service) + + var postAggregationMethods = _.keys(postAggregation) + + return function doQuery(queryObj) { + var queryHash = JSON.stringify(queryObj) + + // Attempt to reuse an exact copy of this query that is present elsewhere + for (var i = 0; i < service.columns.length; i++) { + for (var j = 0; j < service.columns[i].queries.length; j++) { + if (service.columns[i].queries[j].hash === queryHash) { + return new Promise(function (resolve, reject) { // eslint-disable-line no-loop-func + try { + resolve(service.columns[i].queries[j]) + } catch (err) { + reject(err) + } + }) + } + } + } + + var query = { + // Original query passed in to query method + original: queryObj, + hash: queryHash, + } + + // Default queryObj + if (_.isUndefined(query.original)) { + query.original = {} + } + // Default select + if (_.isUndefined(query.original.select)) { + query.original.select = { + $count: true, + } + } + // Default to groupAll + query.original.groupBy = query.original.groupBy || true + + // Attach the query api to the query object + query = newQueryObj(query) + + return createColumn(query) + .then(makeCrossfilterGroup) + .then(buildRequiredColumns) + .then(setupDataListeners) + .then(applyQuery) + + function createColumn(query) { + // Ensure column is created + return service.column({ + key: query.original.groupBy, + type: _.isUndefined(query.type) ? null : query.type, + array: Boolean(query.array), + }) + .then(function () { + // Attach the column to the query + var column = service.column.find(query.original.groupBy) + query.column = column + column.queries.push(query) + column.removeListeners.push(function () { + return query.clear() + }) + return query + }) + } + + function makeCrossfilterGroup(query) { + // Create the grouping on the columns dimension + // Using Promise Resolve allows support for crossfilter async + // TODO check if query already exists, and use the same base query // if possible + return Promise.resolve(query.column.dimension.group()) + .then(function (g) { + query.group = g + return query + }) + } + + function buildRequiredColumns(query) { + var requiredColumns = filters.scanForDynamicFilters(query.original) + // We need to scan the group for any filters that would require + // the group to be rebuilt when data is added or removed in any way. + if (requiredColumns.length) { + return Promise.all(_.map(requiredColumns, function (columnKey) { + return service.column({ + key: columnKey, + dynamicReference: query.group, + }) + })) + .then(function () { + return query + }) + } + return query + } + + function setupDataListeners(query) { + // Here, we create a listener to recreate and apply the reducer to + // the group anytime underlying data changes + var stopDataListen = service.onDataChange(function () { + return applyQuery(query) + }) + query.removeListeners.push(stopDataListen) + + // This is a similar listener for filtering which will (if needed) + // run any post aggregations on the data after each filter action + var stopFilterListen = service.onFilter(function () { + return postAggregate(query) + }) + query.removeListeners.push(stopFilterListen) + + return query + } + + function applyQuery(query) { + return buildReducer(query) + .then(applyReducer) + .then(attachData) + .then(postAggregate) + } + + function buildReducer(query) { + return reductiofy(query.original) + .then(function (reducer) { + query.reducer = reducer + return query + }) + } + + function applyReducer(query) { + return Promise.resolve(query.reducer(query.group)) + .then(function () { + return query + }) + } + + function attachData(query) { + return Promise.resolve(query.group.all()) + .then(function (data) { + query.data = data + return query + }) + } + + function postAggregate(query) { + if (query.postAggregations.length > 1) { + // If the query is used by 2+ post aggregations, we need to lock + // it against getting mutated by the post-aggregations + query.locked = true + } + return Promise.all(_.map(query.postAggregations, function (post) { + return post() + })) + .then(function () { + return query + }) + } + + function newQueryObj(q, parent) { + var locked = false + if (!parent) { + parent = q + q = {} + locked = true + } + + // Assign the regular query properties + _.assign(q, { + // The Universe for continuous promise chaining + universe: service, + // Crossfilter instance + crossfilter: service.cf, + + // parent Information + parent: parent, + column: parent.column, + dimension: parent.dimension, + group: parent.group, + reducer: parent.reducer, + original: parent.original, + hash: parent.hash, + + // It's own removeListeners + removeListeners: [], + + // It's own postAggregations + postAggregations: [], + + // Data method + locked: locked, + lock: lock, + unlock: unlock, + // Disposal method + clear: clearQuery, + }) + + _.forEach(postAggregationMethods, function (method) { + q[method] = postAggregateMethodWrap(postAggregation[method]) + }) + + return q + + function lock(set) { + if (!_.isUndefined(set)) { + q.locked = Boolean(set) + return + } + q.locked = true + } + + function unlock() { + q.locked = false + } + + function clearQuery() { + _.forEach(q.removeListeners, function (l) { + l() + }) + return new Promise(function (resolve, reject) { + try { + resolve(q.group.dispose()) + } catch (err) { + reject(err) + } + }) + .then(function () { + q.column.queries.splice(q.column.queries.indexOf(q), 1) + // Automatically recycle the column if there are no queries active on it + if (!q.column.queries.length) { + return service.clear(q.column.key) + } + }) + .then(function () { + return service + }) + } + + function postAggregateMethodWrap(postMethod) { + return function () { + var args = Array.prototype.slice.call(arguments) + var sub = {} + newQueryObj(sub, q) + args.unshift(sub, q) + + q.postAggregations.push(function () { + Promise.resolve(postMethod.apply(null, args)) + .then(postAggregateChildren) + }) + + return Promise.resolve(postMethod.apply(null, args)) + .then(postAggregateChildren) + + function postAggregateChildren() { + return postAggregate(sub) + .then(function () { + return sub + }) + } + } + } + } + } +} + +},{"./filters":51,"./lodash":52,"./postAggregation":53,"./reductiofy":56}],55:[function(require,module,exports){ +'use strict' + +// var _ = require('./lodash') // _ is defined but never used + +module.exports = { + shorthandLabels: { + $count: 'count', + $sum: 'sum', + $avg: 'avg', + $min: 'min', + $max: 'max', + $med: 'med', + $sumSq: 'sumSq', + $std: 'std', + }, + aggregators: { + $count: $count, + $sum: $sum, + $avg: $avg, + $min: $min, + $max: $max, + $med: $med, + $sumSq: $sumSq, + $std: $std, + $valueList: $valueList, + $dataList: $dataList, + }, +} + +// Aggregators + +function $count(reducer/* , value */) { + return reducer.count(true) +} + +function $sum(reducer, value) { + return reducer.sum(value) +} + +function $avg(reducer, value) { + return reducer.avg(value) +} + +function $min(reducer, value) { + return reducer.min(value) +} + +function $max(reducer, value) { + return reducer.max(value) +} + +function $med(reducer, value) { + return reducer.median(value) +} + +function $sumSq(reducer, value) { + return reducer.sumOfSq(value) +} + +function $std(reducer, value) { + return reducer.std(value) +} + +function $valueList(reducer, value) { + return reducer.valueList(value) +} + +function $dataList(reducer/* , value */) { + return reducer.dataList(true) +} + +// TODO histograms +// TODO exceptions + +},{}],56:[function(require,module,exports){ +'use strict' + +var reductio = require('reductio') + +var _ = require('./lodash') +var rAggregators = require('./reductioAggregators') +// var expressions = require('./expressions') // exporession is defined but never used +var aggregation = require('./aggregation') + +module.exports = function (service) { + var filters = require('./filters')(service) + + return function reductiofy(query) { + var reducer = reductio() + // var groupBy = query.groupBy // groupBy is defined but never used + aggregateOrNest(reducer, query.select) + + if (query.filter) { + var filterFunction = filters.makeFunction(query.filter) + if (filterFunction) { + reducer.filter(filterFunction) + } + } + + return Promise.resolve(reducer) + + // This function recursively find the first level of reductio methods in + // each object and adds that reduction method to reductio + function aggregateOrNest(reducer, selects) { + // Sort so nested values are calculated last by reductio's .value method + var sortedSelectKeyValue = _.sortBy( + _.map(selects, function (val, key) { + return { + key: key, + value: val, + } + }), + function (s) { + if (rAggregators.aggregators[s.key]) { + return 0 + } + return 1 + }) + + // dive into each key/value + return _.forEach(sortedSelectKeyValue, function (s) { + // Found a Reductio Aggregation + if (rAggregators.aggregators[s.key]) { + // Build the valueAccessorFunction + var accessor = aggregation.makeValueAccessor(s.value) + // Add the reducer with the ValueAccessorFunction to the reducer + reducer = rAggregators.aggregators[s.key](reducer, accessor) + return + } + + // Found a top level key value that is not an aggregation or a + // nested object. This is unacceptable. + if (!_.isObject(s.value)) { + console.error('Nested selects must be an object', s.key) + return + } + + // It's another nested object, so just repeat this process on it + aggregateOrNest(reducer.value(s.key), s.value) + }) + } + } +} + +},{"./aggregation":44,"./filters":51,"./lodash":52,"./reductioAggregators":55,"reductio":37}],57:[function(require,module,exports){ +'use strict' + +var _ = require('./lodash') + +module.exports = universe + +function universe(data, options) { + var service = { + options: _.assign({}, options), + columns: [], + filters: {}, + dataListeners: [], + filterListeners: [], + } + + var cf = require('./crossfilter')(service) + var filters = require('./filters')(service) + + data = cf.generateColumns(data) + + return cf.build(data) + .then(function (data) { + service.cf = data + return _.assign(service, { + add: cf.add, + remove: cf.remove, + column: require('./column')(service), + query: require('./query')(service), + filter: filters.filter, + filterAll: filters.filterAll, + applyFilters: filters.applyFilters, + clear: require('./clear')(service), + destroy: require('./destroy')(service), + onDataChange: onDataChange, + onFilter: onFilter, + }) + }) + + function onDataChange(cb) { + service.dataListeners.push(cb) + return function () { + service.dataListeners.splice(service.dataListeners.indexOf(cb), 1) + } + } + + function onFilter(cb) { + service.filterListeners.push(cb) + return function () { + service.filterListeners.splice(service.filterListeners.indexOf(cb), 1) + } + } +} + +},{"./clear":45,"./column":46,"./crossfilter":47,"./destroy":48,"./filters":51,"./lodash":52,"./query":54}]},{},[57])(57) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/crossfilter2/index.js","node_modules/crossfilter2/package.json","node_modules/crossfilter2/src/array.js","node_modules/crossfilter2/src/bisect.js","node_modules/crossfilter2/src/crossfilter.js","node_modules/crossfilter2/src/filter.js","node_modules/crossfilter2/src/heap.js","node_modules/crossfilter2/src/heapselect.js","node_modules/crossfilter2/src/identity.js","node_modules/crossfilter2/src/insertionsort.js","node_modules/crossfilter2/src/null.js","node_modules/crossfilter2/src/permute.js","node_modules/crossfilter2/src/quicksort.js","node_modules/crossfilter2/src/reduce.js","node_modules/crossfilter2/src/zero.js","node_modules/lodash.result/index.js","node_modules/reductio/src/accessors.js","node_modules/reductio/src/alias.js","node_modules/reductio/src/aliasProp.js","node_modules/reductio/src/avg.js","node_modules/reductio/src/build.js","node_modules/reductio/src/cap.js","node_modules/reductio/src/count.js","node_modules/reductio/src/custom.js","node_modules/reductio/src/data-list.js","node_modules/reductio/src/exception-count.js","node_modules/reductio/src/exception-sum.js","node_modules/reductio/src/filter.js","node_modules/reductio/src/histogram.js","node_modules/reductio/src/max.js","node_modules/reductio/src/median.js","node_modules/reductio/src/min.js","node_modules/reductio/src/nest.js","node_modules/reductio/src/parameters.js","node_modules/reductio/src/postprocess.js","node_modules/reductio/src/postprocessors.js","node_modules/reductio/src/reductio.js","node_modules/reductio/src/sortBy.js","node_modules/reductio/src/std.js","node_modules/reductio/src/sum-of-squares.js","node_modules/reductio/src/sum.js","node_modules/reductio/src/value-count.js","node_modules/reductio/src/value-list.js","src/aggregation.js","src/clear.js","src/column.js","src/crossfilter.js","src/destroy.js","src/dimension.js","src/expressions.js","src/filters.js","src/lodash.js","src/postAggregation.js","src/query.js","src/reductioAggregators.js","src/reductiofy.js","src/universe.js"],"names":[],"mappings":"AAAA;ACAA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC56CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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p6BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3RA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9TA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","module.exports = require(\"./src/crossfilter\").crossfilter;\n","module.exports={\n  \"_args\": [\n    [\n      {\n        \"raw\": \"crossfilter2@1.4.3\",\n        \"scope\": null,\n        \"escapedName\": \"crossfilter2\",\n        \"name\": \"crossfilter2\",\n        \"rawSpec\": \"1.4.3\",\n        \"spec\": \"1.4.3\",\n        \"type\": \"version\"\n      },\n      \"/home/christophe/Programming/Polymer/shared/bower_components/universe\"\n    ]\n  ],\n  \"_from\": \"crossfilter2@1.4.3\",\n  \"_id\": \"crossfilter2@1.4.3\",\n  \"_inCache\": true,\n  \"_location\": \"/crossfilter2\",\n  \"_nodeVersion\": \"8.4.0\",\n  \"_npmOperationalInternal\": {\n    \"host\": \"s3://npm-registry-packages\",\n    \"tmp\": \"tmp/crossfilter2-1.4.3.tgz_1506095343532_0.974256619811058\"\n  },\n  \"_npmUser\": {\n    \"name\": \"esjewett\",\n    \"email\": \"esjewett@gmail.com\"\n  },\n  \"_npmVersion\": \"5.4.2\",\n  \"_phantomChildren\": {},\n  \"_requested\": {\n    \"raw\": \"crossfilter2@1.4.3\",\n    \"scope\": null,\n    \"escapedName\": \"crossfilter2\",\n    \"name\": \"crossfilter2\",\n    \"rawSpec\": \"1.4.3\",\n    \"spec\": \"1.4.3\",\n    \"type\": \"version\"\n  },\n  \"_requiredBy\": [\n    \"/\",\n    \"/reductio\"\n  ],\n  \"_resolved\": \"https://registry.npmjs.org/crossfilter2/-/crossfilter2-1.4.3.tgz\",\n  \"_shasum\": \"591361374c8deb8dff35748db2a7c019a491f2e0\",\n  \"_shrinkwrap\": null,\n  \"_spec\": \"crossfilter2@1.4.3\",\n  \"_where\": \"/home/christophe/Programming/Polymer/shared/bower_components/universe\",\n  \"author\": {\n    \"name\": \"Mike Bostock\",\n    \"url\": \"http://bost.ocks.org/mike\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/crossfilter/crossfilter/issues\"\n  },\n  \"contributors\": [\n    {\n      \"name\": \"Jason Davies\",\n      \"url\": \"http://www.jasondavies.com/\"\n    }\n  ],\n  \"dependencies\": {\n    \"lodash.result\": \"^4.4.0\"\n  },\n  \"description\": \"Fast multidimensional filtering for coordinated views.\",\n  \"devDependencies\": {\n    \"browserify\": \"^13.0.0\",\n    \"d3\": \"3.5\",\n    \"eslint\": \"2.10.2\",\n    \"package-json-versionify\": \"1.0.2\",\n    \"semver\": \"^5.3.0\",\n    \"uglify-js\": \"2.4.0\",\n    \"vows\": \"0.7.0\"\n  },\n  \"directories\": {},\n  \"dist\": {\n    \"integrity\": \"sha512-LB0si9wwHufgvIk8ia3WoWDc3mel1OC0ZHe1bUxXE4hZDpino5xBwlw27VI26n8beiAM+Pdknuh55OTHlZz+tg==\",\n    \"shasum\": \"591361374c8deb8dff35748db2a7c019a491f2e0\",\n    \"tarball\": \"https://registry.npmjs.org/crossfilter2/-/crossfilter2-1.4.3.tgz\"\n  },\n  \"eslintConfig\": {\n    \"env\": {\n      \"browser\": true,\n      \"node\": true\n    },\n    \"globals\": {\n      \"Uint8Array\": true,\n      \"Uint16Array\": true,\n      \"Uint32Array\": true\n    },\n    \"extends\": \"eslint:recommended\"\n  },\n  \"files\": [\n    \"src\",\n    \"index.js\",\n    \"crossfilter.js\",\n    \"crossfilter.min.js\"\n  ],\n  \"gitHead\": \"c58c7c8f544c25cfac3bdb591242ca680ca8662c\",\n  \"homepage\": \"http://crossfilter.github.com/crossfilter/\",\n  \"keywords\": [\n    \"analytics\",\n    \"visualization\",\n    \"crossfilter\"\n  ],\n  \"license\": \"Apache-2.0\",\n  \"main\": \"./index.js\",\n  \"maintainers\": [\n    {\n      \"name\": \"esjewett\",\n      \"email\": \"esjewett@gmail.com\"\n    },\n    {\n      \"name\": \"gordonwoodhull\",\n      \"email\": \"gordon@woodhull.com\"\n    },\n    {\n      \"name\": \"tannerlinsley\",\n      \"email\": \"tannerlinsley@gmail.com\"\n    }\n  ],\n  \"name\": \"crossfilter2\",\n  \"optionalDependencies\": {},\n  \"readme\": \"ERROR: No README data found!\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+ssh://git@github.com/crossfilter/crossfilter.git\"\n  },\n  \"scripts\": {\n    \"benchmark\": \"node test/benchmark.js\",\n    \"build\": \"browserify index.js -t package-json-versionify --standalone crossfilter -o crossfilter.js && uglifyjs --compress --mangle --screw-ie8 crossfilter.js -o crossfilter.min.js\",\n    \"clean\": \"rm -f crossfilter.js crossfilter.min.js\",\n    \"test\": \"vows --verbose && eslint src/\"\n  },\n  \"version\": \"1.4.3\"\n}\n","if (typeof Uint8Array !== \"undefined\") {\n  var crossfilter_array8 = function(n) { return new Uint8Array(n); };\n  var crossfilter_array16 = function(n) { return new Uint16Array(n); };\n  var crossfilter_array32 = function(n) { return new Uint32Array(n); };\n\n  var crossfilter_arrayLengthen = function(array, length) {\n    if (array.length >= length) return array;\n    var copy = new array.constructor(length);\n    copy.set(array);\n    return copy;\n  };\n\n  var crossfilter_arrayWiden = function(array, width) {\n    var copy;\n    switch (width) {\n      case 16: copy = crossfilter_array16(array.length); break;\n      case 32: copy = crossfilter_array32(array.length); break;\n      default: throw new Error(\"invalid array width!\");\n    }\n    copy.set(array);\n    return copy;\n  };\n}\n\nfunction crossfilter_arrayUntyped(n) {\n  var array = new Array(n), i = -1;\n  while (++i < n) array[i] = 0;\n  return array;\n}\n\nfunction crossfilter_arrayLengthenUntyped(array, length) {\n  var n = array.length;\n  while (n < length) array[n++] = 0;\n  return array;\n}\n\nfunction crossfilter_arrayWidenUntyped(array, width) {\n  if (width > 32) throw new Error(\"invalid array width!\");\n  return array;\n}\n\n// An arbitrarily-wide array of bitmasks\nfunction crossfilter_bitarray(n) {\n  this.length = n;\n  this.subarrays = 1;\n  this.width = 8;\n  this.masks = {\n    0: 0\n  }\n\n  this[0] = crossfilter_array8(n);\n}\n\ncrossfilter_bitarray.prototype.lengthen = function(n) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    this[i] = crossfilter_arrayLengthen(this[i], n);\n  }\n  this.length = n;\n};\n\n// Reserve a new bit index in the array, returns {offset, one}\ncrossfilter_bitarray.prototype.add = function() {\n  var m, w, one, i, len;\n\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    m = this.masks[i];\n    w = this.width - (32 * i);\n    one = ~m & -~m;\n\n    if (w >= 32 && !one) {\n      continue;\n    }\n\n    if (w < 32 && (one & (1 << w))) {\n      // widen this subarray\n      this[i] = crossfilter_arrayWiden(this[i], w <<= 1);\n      this.width = 32 * i + w;\n    }\n\n    this.masks[i] |= one;\n\n    return {\n      offset: i,\n      one: one\n    };\n  }\n\n  // add a new subarray\n  this[this.subarrays] = crossfilter_array8(this.length);\n  this.masks[this.subarrays] = 1;\n  this.width += 8;\n  return {\n    offset: this.subarrays++,\n    one: 1\n  };\n};\n\n// Copy record from index src to index dest\ncrossfilter_bitarray.prototype.copy = function(dest, src) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    this[i][dest] = this[i][src];\n  }\n};\n\n// Truncate the array to the given length\ncrossfilter_bitarray.prototype.truncate = function(n) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    for (var j = this.length - 1; j >= n; j--) {\n      this[i][j] = 0;\n    }\n    this[i].length = n;\n  }\n  this.length = n;\n};\n\n// Checks that all bits for the given index are 0\ncrossfilter_bitarray.prototype.zero = function(n) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    if (this[i][n]) {\n      return false;\n    }\n  }\n  return true;\n};\n\n// Checks that all bits for the given index are 0 except for possibly one\ncrossfilter_bitarray.prototype.zeroExcept = function(n, offset, zero) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    if (i === offset ? this[i][n] & zero : this[i][n]) {\n      return false;\n    }\n  }\n  return true;\n};\n\n// Checks that all bits for the given indez are 0 except for the specified mask.\n// The mask should be an array of the same size as the filter subarrays width.\ncrossfilter_bitarray.prototype.zeroExceptMask = function(n, mask) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    if (this[i][n] & mask[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// Checks that only the specified bit is set for the given index\ncrossfilter_bitarray.prototype.only = function(n, offset, one) {\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    if (this[i][n] != (i === offset ? one : 0)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n// Checks that only the specified bit is set for the given index except for possibly one other\ncrossfilter_bitarray.prototype.onlyExcept = function(n, offset, zero, onlyOffset, onlyOne) {\n  var mask;\n  var i, len;\n  for (i = 0, len = this.subarrays; i < len; ++i) {\n    mask = this[i][n];\n    if (i === offset)\n      mask &= zero;\n    if (mask != (i === onlyOffset ? onlyOne : 0)) {\n      return false;\n    }\n  }\n  return true;\n};\n\nmodule.exports = {\n  array8: crossfilter_arrayUntyped,\n  array16: crossfilter_arrayUntyped,\n  array32: crossfilter_arrayUntyped,\n  arrayLengthen: crossfilter_arrayLengthenUntyped,\n  arrayWiden: crossfilter_arrayWidenUntyped,\n  bitarray: crossfilter_bitarray\n};\n","'use strict';\n\nvar crossfilter_identity = require('./identity');\n\nfunction bisect_by(f) {\n\n  // Locate the insertion point for x in a to maintain sorted order. The\n  // arguments lo and hi may be used to specify a subset of the array which\n  // should be considered; by default the entire array is used. If x is already\n  // present in a, the insertion point will be before (to the left of) any\n  // existing entries. The return value is suitable for use as the first\n  // argument to `array.splice` assuming that a is already sorted.\n  //\n  // The returned insertion point i partitions the array a into two halves so\n  // that all v < x for v in a[lo:i] for the left side and all v >= x for v in\n  // a[i:hi] for the right side.\n  function bisectLeft(a, x, lo, hi) {\n    while (lo < hi) {\n      var mid = lo + hi >>> 1;\n      if (f(a[mid]) < x) lo = mid + 1;\n      else hi = mid;\n    }\n    return lo;\n  }\n\n  // Similar to bisectLeft, but returns an insertion point which comes after (to\n  // the right of) any existing entries of x in a.\n  //\n  // The returned insertion point i partitions the array into two halves so that\n  // all v <= x for v in a[lo:i] for the left side and all v > x for v in\n  // a[i:hi] for the right side.\n  function bisectRight(a, x, lo, hi) {\n    while (lo < hi) {\n      var mid = lo + hi >>> 1;\n      if (x < f(a[mid])) hi = mid;\n      else lo = mid + 1;\n    }\n    return lo;\n  }\n\n  bisectRight.right = bisectRight;\n  bisectRight.left = bisectLeft;\n  return bisectRight;\n}\n\nmodule.exports = bisect_by(crossfilter_identity);\nmodule.exports.by = bisect_by; // assign the raw function to the export as well\n","'use strict';\n\nvar xfilterArray = require('./array');\nvar xfilterFilter = require('./filter');\nvar crossfilter_identity = require('./identity');\nvar crossfilter_null = require('./null');\nvar crossfilter_zero = require('./zero');\nvar xfilterHeapselect = require('./heapselect');\nvar xfilterHeap = require('./heap');\nvar bisect = require('./bisect');\nvar insertionsort = require('./insertionsort');\nvar permute = require('./permute');\nvar quicksort = require('./quicksort');\nvar xfilterReduce = require('./reduce');\nvar packageJson = require('./../package.json'); // require own package.json for the version field\nvar result = require('lodash.result');\n\n// constants\nvar REMOVED_INDEX = -1;\n\n// expose API exports\nexports.crossfilter = crossfilter;\nexports.crossfilter.heap = xfilterHeap;\nexports.crossfilter.heapselect = xfilterHeapselect;\nexports.crossfilter.bisect = bisect;\nexports.crossfilter.insertionsort = insertionsort;\nexports.crossfilter.permute = permute;\nexports.crossfilter.quicksort = quicksort;\nexports.crossfilter.version = packageJson.version; // please note use of \"package-json-versionify\" transform\n\nfunction crossfilter() {\n  var crossfilter = {\n    add: add,\n    remove: removeData,\n    dimension: dimension,\n    groupAll: groupAll,\n    size: size,\n    all: all,\n    allFiltered: allFiltered,\n    onChange: onChange,\n    isElementFiltered: isElementFiltered\n  };\n\n  var data = [], // the records\n      n = 0, // the number of records; data.length\n      filters, // 1 is filtered out\n      filterListeners = [], // when the filters change\n      dataListeners = [], // when data is added\n      removeDataListeners = [], // when data is removed\n      callbacks = [];\n\n  filters = new xfilterArray.bitarray(0);\n\n  // Adds the specified new records to this crossfilter.\n  function add(newData) {\n    var n0 = n,\n        n1 = newData.length;\n\n    // If there's actually new data to add…\n    // Merge the new data into the existing data.\n    // Lengthen the filter bitset to handle the new records.\n    // Notify listeners (dimensions and groups) that new data is available.\n    if (n1) {\n      data = data.concat(newData);\n      filters.lengthen(n += n1);\n      dataListeners.forEach(function(l) { l(newData, n0, n1); });\n      triggerOnChange('dataAdded');\n    }\n\n    return crossfilter;\n  }\n\n  // Removes all records that match the current filters, or if a predicate function is passed,\n  // removes all records matching the predicate (ignoring filters).\n  function removeData(predicate) {\n    var // Mapping from old record indexes to new indexes (after records removed)\n        newIndex = crossfilter_index(n, n),\n        removed = [],\n        usePred = typeof predicate === 'function',\n        shouldRemove = function (i) {\n          return usePred ? predicate(data[i], i) : filters.zero(i)\n        };\n\n    for (var index1 = 0, index2 = 0; index1 < n; ++index1) {\n      if ( shouldRemove(index1) ) {\n        removed.push(index1);\n        newIndex[index1] = REMOVED_INDEX;\n      } else {\n        newIndex[index1] = index2++;\n      }\n    }\n\n    // Remove all matching records from groups.\n    filterListeners.forEach(function(l) { l(-1, -1, [], removed, true); });\n\n    // Update indexes.\n    removeDataListeners.forEach(function(l) { l(newIndex); });\n\n    // Remove old filters and data by overwriting.\n    for (var index3 = 0, index4 = 0; index3 < n; ++index3) {\n      if ( newIndex[index3] !== REMOVED_INDEX ) {\n        if (index3 !== index4) filters.copy(index4, index3), data[index4] = data[index3];\n        ++index4;\n      }\n    }\n\n    data.length = n = index4;\n    filters.truncate(index4);\n    triggerOnChange('dataRemoved');\n  }\n\n  // Return true if the data element at index i is filtered IN.\n  // Optionally, ignore the filters of any dimensions in the ignore_dimensions list.\n  function isElementFiltered(i, ignore_dimensions) {\n    var n,\n        d,\n        id,\n        len,\n        mask = Array(filters.subarrays);\n    for (n = 0; n < filters.subarrays; n++) { mask[n] = ~0; }\n    if (ignore_dimensions) {\n      for (d = 0, len = ignore_dimensions.length; d < len; d++) {\n        // The top bits of the ID are the subarray offset and the lower bits are the bit\n        // offset of the \"one\" mask.\n        id = ignore_dimensions[d].id();\n        mask[id >> 7] &= ~(0x1 << (id & 0x3f));\n      }\n    }\n    return filters.zeroExceptMask(i,mask);\n  }\n\n  // Adds a new dimension with the specified value accessor function.\n  function dimension(value, iterable) {\n\n    if (typeof value === 'string') {\n      var accessorPath = value;\n      value = function(d) { return result(d, accessorPath); };\n    }\n\n    var dimension = {\n      filter: filter,\n      filterExact: filterExact,\n      filterRange: filterRange,\n      filterFunction: filterFunction,\n      filterAll: filterAll,\n      top: top,\n      bottom: bottom,\n      group: group,\n      groupAll: groupAll,\n      dispose: dispose,\n      remove: dispose, // for backwards-compatibility\n      accessor: value,\n      id: function() { return id; }\n    };\n\n    var one, // lowest unset bit as mask, e.g., 00001000\n        zero, // inverted one, e.g., 11110111\n        offset, // offset into the filters arrays\n        id, // unique ID for this dimension (reused when dimensions are disposed)\n        values, // sorted, cached array\n        index, // maps sorted value index -> record index (in data)\n        newValues, // temporary array storing newly-added values\n        newIndex, // temporary array storing newly-added index\n        iterablesIndexCount,\n        newIterablesIndexCount,\n        iterablesIndexFilterStatus,\n        newIterablesIndexFilterStatus,\n        iterablesEmptyRows = [],\n        sort = quicksort.by(function(i) { return newValues[i]; }),\n        refilter = xfilterFilter.filterAll, // for recomputing filter\n        refilterFunction, // the custom filter function in use\n        indexListeners = [], // when data is added\n        dimensionGroups = [],\n        lo0 = 0,\n        hi0 = 0,\n        t = 0,\n        k;\n\n    // Updating a dimension is a two-stage process. First, we must update the\n    // associated filters for the newly-added records. Once all dimensions have\n    // updated their filters, the groups are notified to update.\n    dataListeners.unshift(preAdd);\n    dataListeners.push(postAdd);\n\n    removeDataListeners.push(removeData);\n\n    // Add a new dimension in the filter bitmap and store the offset and bitmask.\n    var tmp = filters.add();\n    offset = tmp.offset;\n    one = tmp.one;\n    zero = ~one;\n\n    // Create a unique ID for the dimension\n    // IDs will be re-used if dimensions are disposed.\n    // For internal use the ID is the subarray offset shifted left 7 bits or'd with the\n    // bit offset of the set bit in the dimension's \"one\" mask.\n    id = (offset << 7) | (Math.log(one) / Math.log(2));\n\n    preAdd(data, 0, n);\n    postAdd(data, 0, n);\n\n    // Incorporates the specified new records into this dimension.\n    // This function is responsible for updating filters, values, and index.\n    function preAdd(newData, n0, n1) {\n\n      if (iterable){\n        // Count all the values\n        t = 0;\n        j = 0;\n        k = [];\n\n        for (var i0 = 0; i0 < newData.length; i0++) {\n          for(j = 0, k = value(newData[i0]); j < k.length; j++) {\n            t++;\n          }\n        }\n\n        newValues = [];\n        newIterablesIndexCount = crossfilter_range(newData.length);\n        newIterablesIndexFilterStatus = crossfilter_index(t,1);\n        var unsortedIndex = crossfilter_range(t);\n\n        for (var l = 0, index1 = 0; index1 < newData.length; index1++) {\n          k = value(newData[index1])\n          //\n          if(!k.length){\n            newIterablesIndexCount[index1] = 0;\n            iterablesEmptyRows.push(index1 + n0);\n            continue;\n          }\n          newIterablesIndexCount[index1] = k.length\n          for (j = 0; j < k.length; j++) {\n            newValues.push(k[j]);\n            unsortedIndex[l] = index1;\n            l++;\n          }\n        }\n\n        // Create the Sort map used to sort both the values and the valueToData indices\n        var sortMap = sort(crossfilter_range(t), 0, t);\n\n        // Use the sortMap to sort the newValues\n        newValues = permute(newValues, sortMap);\n\n\n        // Use the sortMap to sort the unsortedIndex map\n        // newIndex should be a map of sortedValue -> crossfilterData\n        newIndex = permute(unsortedIndex, sortMap)\n\n      } else{\n        // Permute new values into natural order using a standard sorted index.\n        newValues = newData.map(value);\n        newIndex = sort(crossfilter_range(n1), 0, n1);\n        newValues = permute(newValues, newIndex);\n      }\n\n      if(iterable) {\n        n1 = t;\n      }\n\n      // Bisect newValues to determine which new records are selected.\n      var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1];\n      if (refilterFunction) {\n        for (var index2 = 0; index2 < n1; ++index2) {\n          if (!refilterFunction(newValues[index2], index2)) {\n            filters[offset][newIndex[index2] + n0] |= one;\n            if(iterable) newIterablesIndexFilterStatus[index2] = 1;\n          }\n        }\n      } else {\n        for (var index3 = 0; index3 < lo1; ++index3) {\n          filters[offset][newIndex[index3] + n0] |= one;\n          if(iterable) newIterablesIndexFilterStatus[index3] = 1;\n        }\n        for (var index4 = hi1; index4 < n1; ++index4) {\n          filters[offset][newIndex[index4] + n0] |= one;\n          if(iterable) newIterablesIndexFilterStatus[index4] = 1;\n        }\n      }\n\n      // If this dimension previously had no data, then we don't need to do the\n      // more expensive merge operation; use the new values and index as-is.\n      if (!n0) {\n        values = newValues;\n        index = newIndex;\n        iterablesIndexCount = newIterablesIndexCount;\n        iterablesIndexFilterStatus = newIterablesIndexFilterStatus;\n        lo0 = lo1;\n        hi0 = hi1;\n        return;\n      }\n\n\n\n      var oldValues = values,\n        oldIndex = index,\n        oldIterablesIndexFilterStatus = iterablesIndexFilterStatus,\n        old_n0,\n        i1 = 0;\n\n      i0 = 0;\n\n      if(iterable){\n        old_n0 = n0\n        n0 = oldValues.length;\n        n1 = t\n      }\n\n      // Otherwise, create new arrays into which to merge new and old.\n      values = iterable ? new Array(n0 + n1) : new Array(n);\n      index = iterable ? new Array(n0 + n1) : crossfilter_index(n, n);\n      if(iterable) iterablesIndexFilterStatus = crossfilter_index(n0 + n1, 1);\n\n      // Concatenate the newIterablesIndexCount onto the old one.\n      if(iterable) {\n        var oldiiclength = iterablesIndexCount.length;\n        iterablesIndexCount = xfilterArray.arrayLengthen(iterablesIndexCount, n);\n        for(var j=0; j+oldiiclength < n; j++) {\n          iterablesIndexCount[j+oldiiclength] = newIterablesIndexCount[j];\n        }\n      }\n\n      // Merge the old and new sorted values, and old and new index.\n      var index5 = 0;\n      for (; i0 < n0 && i1 < n1; ++index5) {\n        if (oldValues[i0] < newValues[i1]) {\n          values[index5] = oldValues[i0];\n          if(iterable) iterablesIndexFilterStatus[index5] = oldIterablesIndexFilterStatus[i0];\n          index[index5] = oldIndex[i0++];\n        } else {\n          values[index5] = newValues[i1];\n          if(iterable) iterablesIndexFilterStatus[index5] = newIterablesIndexFilterStatus[i1];\n          index[index5] = newIndex[i1++] + (iterable ? old_n0 : n0);\n        }\n      }\n\n      // Add any remaining old values.\n      for (; i0 < n0; ++i0, ++index5) {\n        values[index5] = oldValues[i0];\n        if(iterable) iterablesIndexFilterStatus[index5] = oldIterablesIndexFilterStatus[i0];\n        index[index5] = oldIndex[i0];\n      }\n\n      // Add any remaining new values.\n      for (; i1 < n1; ++i1, ++index5) {\n        values[index5] = newValues[i1];\n        if(iterable) iterablesIndexFilterStatus[index5] = newIterablesIndexFilterStatus[i1];\n        index[index5] = newIndex[i1] + (iterable ? old_n0 : n0);\n      }\n\n      // Bisect again to recompute lo0 and hi0.\n      bounds = refilter(values), lo0 = bounds[0], hi0 = bounds[1];\n    }\n\n    // When all filters have updated, notify index listeners of the new values.\n    function postAdd(newData, n0, n1) {\n      indexListeners.forEach(function(l) { l(newValues, newIndex, n0, n1); });\n      newValues = newIndex = null;\n    }\n\n    function removeData(reIndex) {\n      if (iterable) {\n        for (var i0 = 0, i1 = 0; i0 < iterablesEmptyRows.length; i0++) {\n          if (reIndex[iterablesEmptyRows[i0]] !== REMOVED_INDEX) {\n            iterablesEmptyRows[i1] = reIndex[iterablesEmptyRows[i0]];\n            i1++;\n          }\n        }\n        iterablesEmptyRows.length = i1;\n        for (i0 = 0, i1 = 0; i0 < n; i0++) {\n          if (reIndex[i0] !== REMOVED_INDEX) {\n            if (i1 !== i0) iterablesIndexCount[i1] = iterablesIndexCount[i0];\n            i1++;\n          }\n        }\n        iterablesIndexCount.length = i1;\n      }\n      // Rewrite our index, overwriting removed values\n      var n0 = values.length;\n      for (var i = 0, j = 0, oldDataIndex; i < n0; ++i) {\n        oldDataIndex = index[i];\n        if (reIndex[oldDataIndex] !== REMOVED_INDEX) {\n          if (i !== j) values[j] = values[i];\n          index[j] = reIndex[oldDataIndex];\n          if (iterable) {\n            iterablesIndexFilterStatus[j] = iterablesIndexFilterStatus[i];\n          }\n          ++j;\n        }\n      }\n      values.length = j;\n      if (iterable) iterablesIndexFilterStatus.length = j;\n      while (j < n0) index[j++] = 0;\n\n      // Bisect again to recompute lo0 and hi0.\n      var bounds = refilter(values);\n      lo0 = bounds[0], hi0 = bounds[1];\n    }\n\n    // Updates the selected values based on the specified bounds [lo, hi].\n    // This implementation is used by all the public filter methods.\n    function filterIndexBounds(bounds) {\n\n      var lo1 = bounds[0],\n          hi1 = bounds[1];\n\n      if (refilterFunction) {\n        refilterFunction = null;\n        filterIndexFunction(function(d, i) { return lo1 <= i && i < hi1; }, bounds[0] === 0 && bounds[1] === values.length);\n        lo0 = lo1;\n        hi0 = hi1;\n        return dimension;\n      }\n\n      var i,\n          j,\n          k,\n          added = [],\n          removed = [],\n          valueIndexAdded = [],\n          valueIndexRemoved = [];\n\n\n      // Fast incremental update based on previous lo index.\n      if (lo1 < lo0) {\n        for (i = lo1, j = Math.min(lo0, hi1); i < j; ++i) {\n          added.push(index[i]);\n          valueIndexAdded.push(i);\n        }\n      } else if (lo1 > lo0) {\n        for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) {\n          removed.push(index[i]);\n          valueIndexRemoved.push(i);\n        }\n      }\n\n      // Fast incremental update based on previous hi index.\n      if (hi1 > hi0) {\n        for (i = Math.max(lo1, hi0), j = hi1; i < j; ++i) {\n          added.push(index[i]);\n          valueIndexAdded.push(i);\n        }\n      } else if (hi1 < hi0) {\n        for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) {\n          removed.push(index[i]);\n          valueIndexRemoved.push(i);\n        }\n      }\n\n      if(!iterable) {\n        // Flip filters normally.\n\n        for(i=0; i<added.length; i++) {\n          filters[offset][added[i]] ^= one;\n        }\n\n        for(i=0; i<removed.length; i++) {\n          filters[offset][removed[i]] ^= one;\n        }\n\n      } else {\n        // For iterables, we need to figure out if the row has been completely removed vs partially included\n        // Only count a row as added if it is not already being aggregated. Only count a row\n        // as removed if the last element being aggregated is removed.\n\n        var newAdded = [];\n        var newRemoved = [];\n        for (i = 0; i < added.length; i++) {\n          iterablesIndexCount[added[i]]++\n          iterablesIndexFilterStatus[valueIndexAdded[i]] = 0;\n          if(iterablesIndexCount[added[i]] === 1) {\n            filters[offset][added[i]] ^= one;\n            newAdded.push(added[i]);\n          }\n        }\n        for (i = 0; i < removed.length; i++) {\n          iterablesIndexCount[removed[i]]--\n          iterablesIndexFilterStatus[valueIndexRemoved[i]] = 1;\n          if(iterablesIndexCount[removed[i]] === 0) {\n            filters[offset][removed[i]] ^= one;\n            newRemoved.push(removed[i]);\n          }\n        }\n\n        added = newAdded;\n        removed = newRemoved;\n\n        // Now handle empty rows.\n        if(bounds[0] === 0 && bounds[1] === values.length) {\n          for(i = 0; i < iterablesEmptyRows.length; i++) {\n            if((filters[offset][k = iterablesEmptyRows[i]] & one)) {\n              // Was not in the filter, so set the filter and add\n              filters[offset][k] ^= one;\n              added.push(k);\n            }\n          }\n        } else {\n          // filter in place - remove empty rows if necessary\n          for(i = 0; i < iterablesEmptyRows.length; i++) {\n            if(!(filters[offset][k = iterablesEmptyRows[i]] & one)) {\n              // Was in the filter, so set the filter and remove\n              filters[offset][k] ^= one;\n              removed.push(k);\n            }\n          }\n        }\n      }\n\n      lo0 = lo1;\n      hi0 = hi1;\n      filterListeners.forEach(function(l) { l(one, offset, added, removed); });\n      triggerOnChange('filtered');\n      return dimension;\n    }\n\n    // Filters this dimension using the specified range, value, or null.\n    // If the range is null, this is equivalent to filterAll.\n    // If the range is an array, this is equivalent to filterRange.\n    // Otherwise, this is equivalent to filterExact.\n    function filter(range) {\n      return range == null\n          ? filterAll() : Array.isArray(range)\n          ? filterRange(range) : typeof range === \"function\"\n          ? filterFunction(range)\n          : filterExact(range);\n    }\n\n    // Filters this dimension to select the exact value.\n    function filterExact(value) {\n      return filterIndexBounds((refilter = xfilterFilter.filterExact(bisect, value))(values));\n    }\n\n    // Filters this dimension to select the specified range [lo, hi].\n    // The lower bound is inclusive, and the upper bound is exclusive.\n    function filterRange(range) {\n      return filterIndexBounds((refilter = xfilterFilter.filterRange(bisect, range))(values));\n    }\n\n    // Clears any filters on this dimension.\n    function filterAll() {\n      return filterIndexBounds((refilter = xfilterFilter.filterAll)(values));\n    }\n\n    // Filters this dimension using an arbitrary function.\n    function filterFunction(f) {\n      refilterFunction = f;\n      refilter = xfilterFilter.filterAll;\n\n      filterIndexFunction(f, false);\n\n      var bounds = refilter(values);\n      lo0 = bounds[0], hi0 = bounds[1];\n\n      return dimension;\n    }\n\n    function filterIndexFunction(f, filterAll) {\n      var i,\n          k,\n          x,\n          added = [],\n          removed = [],\n          valueIndexAdded = [],\n          valueIndexRemoved = [],\n          indexLength = values.length;\n\n      if(!iterable) {\n        for (i = 0; i < indexLength; ++i) {\n          if (!(filters[offset][k = index[i]] & one) ^ !!(x = f(values[i], i))) {\n            if (x) added.push(k);\n            else removed.push(k);\n          }\n        }\n      }\n\n      if(iterable) {\n        for(i=0; i < indexLength; ++i) {\n          if(f(values[i], i)) {\n            added.push(index[i]);\n            valueIndexAdded.push(i);\n          } else {\n            removed.push(index[i]);\n            valueIndexRemoved.push(i);\n          }\n        }\n      }\n\n      if(!iterable) {\n        for(i=0; i<added.length; i++) {\n          if(filters[offset][added[i]] & one) filters[offset][added[i]] &= zero;\n        }\n\n        for(i=0; i<removed.length; i++) {\n          if(!(filters[offset][removed[i]] & one)) filters[offset][removed[i]] |= one;\n        }\n      } else {\n\n        var newAdded = [];\n        var newRemoved = [];\n        for (i = 0; i < added.length; i++) {\n          // First check this particular value needs to be added\n          if(iterablesIndexFilterStatus[valueIndexAdded[i]] === 1) {\n            iterablesIndexCount[added[i]]++\n            iterablesIndexFilterStatus[valueIndexAdded[i]] = 0;\n            if(iterablesIndexCount[added[i]] === 1) {\n              filters[offset][added[i]] ^= one;\n              newAdded.push(added[i]);\n            }\n          }\n        }\n        for (i = 0; i < removed.length; i++) {\n          // First check this particular value needs to be removed\n          if(iterablesIndexFilterStatus[valueIndexRemoved[i]] === 0) {\n            iterablesIndexCount[removed[i]]--\n            iterablesIndexFilterStatus[valueIndexRemoved[i]] = 1;\n            if(iterablesIndexCount[removed[i]] === 0) {\n              filters[offset][removed[i]] ^= one;\n              newRemoved.push(removed[i]);\n            }\n          }\n        }\n\n        added = newAdded;\n        removed = newRemoved;\n\n        // Now handle empty rows.\n        if(filterAll) {\n          for(i = 0; i < iterablesEmptyRows.length; i++) {\n            if((filters[offset][k = iterablesEmptyRows[i]] & one)) {\n              // Was not in the filter, so set the filter and add\n              filters[offset][k] ^= one;\n              added.push(k);\n            }\n          }\n        } else {\n          // filter in place - remove empty rows if necessary\n          for(i = 0; i < iterablesEmptyRows.length; i++) {\n            if(!(filters[offset][k = iterablesEmptyRows[i]] & one)) {\n              // Was in the filter, so set the filter and remove\n              filters[offset][k] ^= one;\n              removed.push(k);\n            }\n          }\n        }\n      }\n\n      filterListeners.forEach(function(l) { l(one, offset, added, removed); });\n      triggerOnChange('filtered');\n    }\n\n    // Returns the top K selected records based on this dimension's order.\n    // Note: observes this dimension's filter, unlike group and groupAll.\n    function top(k, top_offset) {\n      var array = [],\n          i = hi0,\n          j,\n          toSkip = 0;\n\n      if(top_offset && top_offset > 0) toSkip = top_offset;\n\n      while (--i >= lo0 && k > 0) {\n        if (filters.zero(j = index[i])) {\n          if(toSkip > 0) {\n            //skip matching row\n            --toSkip;\n          } else {\n            array.push(data[j]);\n            --k;\n          }\n        }\n      }\n\n      if(iterable){\n        for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) {\n          // Add row with empty iterable column at the end\n          if(filters.zero(j = iterablesEmptyRows[i])) {\n            if(toSkip > 0) {\n              //skip matching row\n              --toSkip;\n            } else {\n              array.push(data[j]);\n              --k;\n            }\n          }\n        }\n      }\n\n      return array;\n    }\n\n    // Returns the bottom K selected records based on this dimension's order.\n    // Note: observes this dimension's filter, unlike group and groupAll.\n    function bottom(k, bottom_offset) {\n      var array = [],\n          i,\n          j,\n          toSkip = 0;\n\n      if(bottom_offset && bottom_offset > 0) toSkip = bottom_offset;\n\n      if(iterable) {\n        // Add row with empty iterable column at the top\n        for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) {\n          if(filters.zero(j = iterablesEmptyRows[i])) {\n            if(toSkip > 0) {\n              //skip matching row\n              --toSkip;\n            } else {\n              array.push(data[j]);\n              --k;\n            }\n          }\n        }\n      }\n\n      i = lo0;\n\n      while (i < hi0 && k > 0) {\n        if (filters.zero(j = index[i])) {\n          if(toSkip > 0) {\n            //skip matching row\n            --toSkip;\n          } else {\n            array.push(data[j]);\n            --k;\n          }\n        }\n        i++;\n      }\n\n      return array;\n    }\n\n    // Adds a new group to this dimension, using the specified key function.\n    function group(key) {\n      var group = {\n        top: top,\n        all: all,\n        reduce: reduce,\n        reduceCount: reduceCount,\n        reduceSum: reduceSum,\n        order: order,\n        orderNatural: orderNatural,\n        size: size,\n        dispose: dispose,\n        remove: dispose // for backwards-compatibility\n      };\n\n      // Ensure that this group will be removed when the dimension is removed.\n      dimensionGroups.push(group);\n\n      var groups, // array of {key, value}\n          groupIndex, // object id ↦ group id\n          groupWidth = 8,\n          groupCapacity = crossfilter_capacity(groupWidth),\n          k = 0, // cardinality\n          select,\n          heap,\n          reduceAdd,\n          reduceRemove,\n          reduceInitial,\n          update = crossfilter_null,\n          reset = crossfilter_null,\n          resetNeeded = true,\n          groupAll = key === crossfilter_null,\n          n0old;\n\n      if (arguments.length < 1) key = crossfilter_identity;\n\n      // The group listens to the crossfilter for when any dimension changes, so\n      // that it can update the associated reduce values. It must also listen to\n      // the parent dimension for when data is added, and compute new keys.\n      filterListeners.push(update);\n      indexListeners.push(add);\n      removeDataListeners.push(removeData);\n\n      // Incorporate any existing data into the grouping.\n      add(values, index, 0, n);\n\n      // Incorporates the specified new values into this group.\n      // This function is responsible for updating groups and groupIndex.\n      function add(newValues, newIndex, n0, n1) {\n\n        if(iterable) {\n          n0old = n0\n          n0 = values.length - newValues.length\n          n1 = newValues.length;\n        }\n\n        var oldGroups = groups,\n            reIndex = iterable ? [] : crossfilter_index(k, groupCapacity),\n            add = reduceAdd,\n            remove = reduceRemove,\n            initial = reduceInitial,\n            k0 = k, // old cardinality\n            i0 = 0, // index of old group\n            i1 = 0, // index of new record\n            j, // object id\n            g0, // old group\n            x0, // old key\n            x1, // new key\n            g, // group to add\n            x; // key of group to add\n\n        // If a reset is needed, we don't need to update the reduce values.\n        if (resetNeeded) add = initial = crossfilter_null;\n        if (resetNeeded) remove = initial = crossfilter_null;\n\n        // Reset the new groups (k is a lower bound).\n        // Also, make sure that groupIndex exists and is long enough.\n        groups = new Array(k), k = 0;\n        if(iterable){\n          groupIndex = k0 ? groupIndex : [];\n        }\n        else{\n          groupIndex = k0 > 1 ? xfilterArray.arrayLengthen(groupIndex, n) : crossfilter_index(n, groupCapacity);\n        }\n\n\n        // Get the first old key (x0 of g0), if it exists.\n        if (k0) x0 = (g0 = oldGroups[0]).key;\n\n        // Find the first new key (x1), skipping NaN keys.\n        while (i1 < n1 && !((x1 = key(newValues[i1])) >= x1)) ++i1;\n\n        // While new keys remain…\n        while (i1 < n1) {\n\n          // Determine the lesser of the two current keys; new and old.\n          // If there are no old keys remaining, then always add the new key.\n          if (g0 && x0 <= x1) {\n            g = g0, x = x0;\n\n            // Record the new index of the old group.\n            reIndex[i0] = k;\n\n            // Retrieve the next old key.\n            g0 = oldGroups[++i0];\n            if (g0) x0 = g0.key;\n          } else {\n            g = {key: x1, value: initial()}, x = x1;\n          }\n\n          // Add the lesser group.\n          groups[k] = g;\n\n          // Add any selected records belonging to the added group, while\n          // advancing the new key and populating the associated group index.\n\n          while (x1 <= x) {\n            j = newIndex[i1] + (iterable ? n0old : n0)\n\n\n            if(iterable){\n              if(groupIndex[j]){\n                groupIndex[j].push(k)\n              }\n              else{\n                groupIndex[j] = [k]\n              }\n            }\n            else{\n              groupIndex[j] = k;\n            }\n\n            // Always add new values to groups. Only remove when not in filter.\n            // This gives groups full information on data life-cycle.\n            g.value = add(g.value, data[j], true);\n            if (!filters.zeroExcept(j, offset, zero)) g.value = remove(g.value, data[j], false);\n            if (++i1 >= n1) break;\n            x1 = key(newValues[i1]);\n          }\n\n          groupIncrement();\n        }\n\n        // Add any remaining old groups that were greater th1an all new keys.\n        // No incremental reduce is needed; these groups have no new records.\n        // Also record the new index of the old group.\n        while (i0 < k0) {\n          groups[reIndex[i0] = k] = oldGroups[i0++];\n          groupIncrement();\n        }\n\n\n        // Fill in gaps with empty arrays where there may have been rows with empty iterables\n        if(iterable){\n          for (var index1 = 0; index1 < n; index1++) {\n            if(!groupIndex[index1]){\n              groupIndex[index1] = [];\n            }\n          }\n        }\n\n        // If we added any new groups before any old groups,\n        // update the group index of all the old records.\n        if(k > i0){\n          if(iterable){\n            for (i0 = 0; i0 < n0old; ++i0) {\n              for (index1 = 0; index1 < groupIndex[i0].length; index1++) {\n                groupIndex[i0][index1] = reIndex[groupIndex[i0][index1]];\n              }\n            }\n          }\n          else{\n            for (i0 = 0; i0 < n0; ++i0) {\n              groupIndex[i0] = reIndex[groupIndex[i0]];\n            }\n          }\n        }\n\n        // Modify the update and reset behavior based on the cardinality.\n        // If the cardinality is less than or equal to one, then the groupIndex\n        // is not needed. If the cardinality is zero, then there are no records\n        // and therefore no groups to update or reset. Note that we also must\n        // change the registered listener to point to the new method.\n        j = filterListeners.indexOf(update);\n        if (k > 1 || iterable) {\n          update = updateMany;\n          reset = resetMany;\n        } else {\n          if (!k && groupAll) {\n            k = 1;\n            groups = [{key: null, value: initial()}];\n          }\n          if (k === 1) {\n            update = updateOne;\n            reset = resetOne;\n          } else {\n            update = crossfilter_null;\n            reset = crossfilter_null;\n          }\n          groupIndex = null;\n        }\n        filterListeners[j] = update;\n\n        // Count the number of added groups,\n        // and widen the group index as needed.\n        function groupIncrement() {\n          if(iterable){\n            k++\n            return\n          }\n          if (++k === groupCapacity) {\n            reIndex = xfilterArray.arrayWiden(reIndex, groupWidth <<= 1);\n            groupIndex = xfilterArray.arrayWiden(groupIndex, groupWidth);\n            groupCapacity = crossfilter_capacity(groupWidth);\n          }\n        }\n      }\n\n      function removeData(reIndex) {\n        if (k > 1 || iterable) {\n          var oldK = k,\n              oldGroups = groups,\n              seenGroups = crossfilter_index(oldK, oldK),\n              i,\n              i0,\n              j;\n\n          // Filter out non-matches by copying matching group index entries to\n          // the beginning of the array.\n          if (!iterable) {\n            for (i = 0, j = 0; i < n; ++i) {\n              if (reIndex[i] !== REMOVED_INDEX) {\n                seenGroups[groupIndex[j] = groupIndex[i]] = 1;\n                ++j;\n              }\n            }\n          } else {\n            for (i = 0, j = 0; i < n; ++i) {\n              if (reIndex[i] !== REMOVED_INDEX) {\n                groupIndex[j] = groupIndex[i];\n                for (i0 = 0; i0 < groupIndex[j].length; i0++) {\n                  seenGroups[groupIndex[j][i0]] = 1;\n                }\n                ++j;\n              }\n            }\n          }\n\n          // Reassemble groups including only those groups that were referred\n          // to by matching group index entries.  Note the new group index in\n          // seenGroups.\n          groups = [], k = 0;\n          for (i = 0; i < oldK; ++i) {\n            if (seenGroups[i]) {\n              seenGroups[i] = k++;\n              groups.push(oldGroups[i]);\n            }\n          }\n\n          if (k > 1 || iterable) {\n            // Reindex the group index using seenGroups to find the new index.\n            if (!iterable) {\n              for (i = 0; i < j; ++i) groupIndex[i] = seenGroups[groupIndex[i]];\n            } else {\n              for (i = 0; i < j; ++i) {\n                for (i0 = 0; i0 < groupIndex[i].length; ++i0) {\n                  groupIndex[i][i0] = seenGroups[groupIndex[i][i0]];\n                }\n              }\n            }\n          } else {\n            groupIndex = null;\n          }\n          filterListeners[filterListeners.indexOf(update)] = k > 1 || iterable\n              ? (reset = resetMany, update = updateMany)\n              : k === 1 ? (reset = resetOne, update = updateOne)\n              : reset = update = crossfilter_null;\n        } else if (k === 1) {\n          if (groupAll) return;\n          for (var index3 = 0; index3 < n; ++index3) if (reIndex[index3] !== REMOVED_INDEX) return;\n          groups = [], k = 0;\n          filterListeners[filterListeners.indexOf(update)] =\n          update = reset = crossfilter_null;\n        }\n      }\n\n      // Reduces the specified selected or deselected records.\n      // This function is only used when the cardinality is greater than 1.\n      // notFilter indicates a crossfilter.add/remove operation.\n      function updateMany(filterOne, filterOffset, added, removed, notFilter) {\n\n        if ((filterOne === one && filterOffset === offset) || resetNeeded) return;\n\n        var i,\n            j,\n            k,\n            n,\n            g;\n\n        if(iterable){\n          // Add the added values.\n          for (i = 0, n = added.length; i < n; ++i) {\n            if (filters.zeroExcept(k = added[i], offset, zero)) {\n              for (j = 0; j < groupIndex[k].length; j++) {\n                g = groups[groupIndex[k][j]];\n                g.value = reduceAdd(g.value, data[k], false, j);\n              }\n            }\n          }\n\n          // Remove the removed values.\n          for (i = 0, n = removed.length; i < n; ++i) {\n            if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) {\n              for (j = 0; j < groupIndex[k].length; j++) {\n                g = groups[groupIndex[k][j]];\n                g.value = reduceRemove(g.value, data[k], notFilter, j);\n              }\n            }\n          }\n          return;\n        }\n\n        // Add the added values.\n        for (i = 0, n = added.length; i < n; ++i) {\n          if (filters.zeroExcept(k = added[i], offset, zero)) {\n            g = groups[groupIndex[k]];\n            g.value = reduceAdd(g.value, data[k], false);\n          }\n        }\n\n        // Remove the removed values.\n        for (i = 0, n = removed.length; i < n; ++i) {\n          if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) {\n            g = groups[groupIndex[k]];\n            g.value = reduceRemove(g.value, data[k], notFilter);\n          }\n        }\n      }\n\n      // Reduces the specified selected or deselected records.\n      // This function is only used when the cardinality is 1.\n      // notFilter indicates a crossfilter.add/remove operation.\n      function updateOne(filterOne, filterOffset, added, removed, notFilter) {\n        if ((filterOne === one && filterOffset === offset) || resetNeeded) return;\n\n        var i,\n            k,\n            n,\n            g = groups[0];\n\n        // Add the added values.\n        for (i = 0, n = added.length; i < n; ++i) {\n          if (filters.zeroExcept(k = added[i], offset, zero)) {\n            g.value = reduceAdd(g.value, data[k], false);\n          }\n        }\n\n        // Remove the removed values.\n        for (i = 0, n = removed.length; i < n; ++i) {\n          if (filters.onlyExcept(k = removed[i], offset, zero, filterOffset, filterOne)) {\n            g.value = reduceRemove(g.value, data[k], notFilter);\n          }\n        }\n      }\n\n      // Recomputes the group reduce values from scratch.\n      // This function is only used when the cardinality is greater than 1.\n      function resetMany() {\n        var i,\n            j,\n            g;\n\n        // Reset all group values.\n        for (i = 0; i < k; ++i) {\n          groups[i].value = reduceInitial();\n        }\n\n        // We add all records and then remove filtered records so that reducers\n        // can build an 'unfiltered' view even if there are already filters in\n        // place on other dimensions.\n        if(iterable){\n          for (i = 0; i < n; ++i) {\n            for (j = 0; j < groupIndex[i].length; j++) {\n              g = groups[groupIndex[i][j]];\n              g.value = reduceAdd(g.value, data[i], true, j);\n            }\n          }\n          for (i = 0; i < n; ++i) {\n            if (!filters.zeroExcept(i, offset, zero)) {\n              for (j = 0; j < groupIndex[i].length; j++) {\n                g = groups[groupIndex[i][j]];\n                g.value = reduceRemove(g.value, data[i], false, j);\n              }\n            }\n          }\n          return;\n        }\n\n        for (i = 0; i < n; ++i) {\n          g = groups[groupIndex[i]];\n          g.value = reduceAdd(g.value, data[i], true);\n        }\n        for (i = 0; i < n; ++i) {\n          if (!filters.zeroExcept(i, offset, zero)) {\n            g = groups[groupIndex[i]];\n            g.value = reduceRemove(g.value, data[i], false);\n          }\n        }\n      }\n\n      // Recomputes the group reduce values from scratch.\n      // This function is only used when the cardinality is 1.\n      function resetOne() {\n        var i,\n            g = groups[0];\n\n        // Reset the singleton group values.\n        g.value = reduceInitial();\n\n        // We add all records and then remove filtered records so that reducers\n        // can build an 'unfiltered' view even if there are already filters in\n        // place on other dimensions.\n        for (i = 0; i < n; ++i) {\n          g.value = reduceAdd(g.value, data[i], true);\n        }\n\n        for (i = 0; i < n; ++i) {\n          if (!filters.zeroExcept(i, offset, zero)) {\n            g.value = reduceRemove(g.value, data[i], false);\n          }\n        }\n      }\n\n      // Returns the array of group values, in the dimension's natural order.\n      function all() {\n        if (resetNeeded) reset(), resetNeeded = false;\n        return groups;\n      }\n\n      // Returns a new array containing the top K group values, in reduce order.\n      function top(k) {\n        var top = select(all(), 0, groups.length, k);\n        return heap.sort(top, 0, top.length);\n      }\n\n      // Sets the reduce behavior for this group to use the specified functions.\n      // This method lazily recomputes the reduce values, waiting until needed.\n      function reduce(add, remove, initial) {\n        reduceAdd = add;\n        reduceRemove = remove;\n        reduceInitial = initial;\n        resetNeeded = true;\n        return group;\n      }\n\n      // A convenience method for reducing by count.\n      function reduceCount() {\n        return reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, crossfilter_zero);\n      }\n\n      // A convenience method for reducing by sum(value).\n      function reduceSum(value) {\n        return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), crossfilter_zero);\n      }\n\n      // Sets the reduce order, using the specified accessor.\n      function order(value) {\n        select = xfilterHeapselect.by(valueOf);\n        heap = xfilterHeap.by(valueOf);\n        function valueOf(d) { return value(d.value); }\n        return group;\n      }\n\n      // A convenience method for natural ordering by reduce value.\n      function orderNatural() {\n        return order(crossfilter_identity);\n      }\n\n      // Returns the cardinality of this group, irrespective of any filters.\n      function size() {\n        return k;\n      }\n\n      // Removes this group and associated event listeners.\n      function dispose() {\n        var i = filterListeners.indexOf(update);\n        if (i >= 0) filterListeners.splice(i, 1);\n        i = indexListeners.indexOf(add);\n        if (i >= 0) indexListeners.splice(i, 1);\n        i = removeDataListeners.indexOf(removeData);\n        if (i >= 0) removeDataListeners.splice(i, 1);\n        return group;\n      }\n\n      return reduceCount().orderNatural();\n    }\n\n    // A convenience function for generating a singleton group.\n    function groupAll() {\n      var g = group(crossfilter_null), all = g.all;\n      delete g.all;\n      delete g.top;\n      delete g.order;\n      delete g.orderNatural;\n      delete g.size;\n      g.value = function() { return all()[0].value; };\n      return g;\n    }\n\n    // Removes this dimension and associated groups and event listeners.\n    function dispose() {\n      dimensionGroups.forEach(function(group) { group.dispose(); });\n      var i = dataListeners.indexOf(preAdd);\n      if (i >= 0) dataListeners.splice(i, 1);\n      i = dataListeners.indexOf(postAdd);\n      if (i >= 0) dataListeners.splice(i, 1);\n      i = removeDataListeners.indexOf(removeData);\n      if (i >= 0) removeDataListeners.splice(i, 1);\n      filters.masks[offset] &= zero;\n      return filterAll();\n    }\n\n    return dimension;\n  }\n\n  // A convenience method for groupAll on a dummy dimension.\n  // This implementation can be optimized since it always has cardinality 1.\n  function groupAll() {\n    var group = {\n      reduce: reduce,\n      reduceCount: reduceCount,\n      reduceSum: reduceSum,\n      value: value,\n      dispose: dispose,\n      remove: dispose // for backwards-compatibility\n    };\n\n    var reduceValue,\n        reduceAdd,\n        reduceRemove,\n        reduceInitial,\n        resetNeeded = true;\n\n    // The group listens to the crossfilter for when any dimension changes, so\n    // that it can update the reduce value. It must also listen to the parent\n    // dimension for when data is added.\n    filterListeners.push(update);\n    dataListeners.push(add);\n\n    // For consistency; actually a no-op since resetNeeded is true.\n    add(data, 0, n);\n\n    // Incorporates the specified new values into this group.\n    function add(newData, n0) {\n      var i;\n\n      if (resetNeeded) return;\n\n      // Cycle through all the values.\n      for (i = n0; i < n; ++i) {\n\n        // Add all values all the time.\n        reduceValue = reduceAdd(reduceValue, data[i], true);\n\n        // Remove the value if filtered.\n        if (!filters.zero(i)) {\n          reduceValue = reduceRemove(reduceValue, data[i], false);\n        }\n      }\n    }\n\n    // Reduces the specified selected or deselected records.\n    function update(filterOne, filterOffset, added, removed, notFilter) {\n      var i,\n          k,\n          n;\n\n      if (resetNeeded) return;\n\n      // Add the added values.\n      for (i = 0, n = added.length; i < n; ++i) {\n        if (filters.zero(k = added[i])) {\n          reduceValue = reduceAdd(reduceValue, data[k], notFilter);\n        }\n      }\n\n      // Remove the removed values.\n      for (i = 0, n = removed.length; i < n; ++i) {\n        if (filters.only(k = removed[i], filterOffset, filterOne)) {\n          reduceValue = reduceRemove(reduceValue, data[k], notFilter);\n        }\n      }\n    }\n\n    // Recomputes the group reduce value from scratch.\n    function reset() {\n      var i;\n\n      reduceValue = reduceInitial();\n\n      // Cycle through all the values.\n      for (i = 0; i < n; ++i) {\n\n        // Add all values all the time.\n        reduceValue = reduceAdd(reduceValue, data[i], true);\n\n        // Remove the value if it is filtered.\n        if (!filters.zero(i)) {\n          reduceValue = reduceRemove(reduceValue, data[i], false);\n        }\n      }\n    }\n\n    // Sets the reduce behavior for this group to use the specified functions.\n    // This method lazily recomputes the reduce value, waiting until needed.\n    function reduce(add, remove, initial) {\n      reduceAdd = add;\n      reduceRemove = remove;\n      reduceInitial = initial;\n      resetNeeded = true;\n      return group;\n    }\n\n    // A convenience method for reducing by count.\n    function reduceCount() {\n      return reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, crossfilter_zero);\n    }\n\n    // A convenience method for reducing by sum(value).\n    function reduceSum(value) {\n      return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), crossfilter_zero);\n    }\n\n    // Returns the computed reduce value.\n    function value() {\n      if (resetNeeded) reset(), resetNeeded = false;\n      return reduceValue;\n    }\n\n    // Removes this group and associated event listeners.\n    function dispose() {\n      var i = filterListeners.indexOf(update);\n      if (i >= 0) filterListeners.splice(i, 1);\n      i = dataListeners.indexOf(add);\n      if (i >= 0) dataListeners.splice(i, 1);\n      return group;\n    }\n\n    return reduceCount();\n  }\n\n  // Returns the number of records in this crossfilter, irrespective of any filters.\n  function size() {\n    return n;\n  }\n\n  // Returns the raw row data contained in this crossfilter\n  function all(){\n    return data;\n  }\n\n  // Returns row data with all dimension filters applied\n  function allFiltered() {\n    var array = [],\n        i = 0;\n\n      for (i = 0; i < n; i++) {\n        if (filters.zero(i)) {\n          array.push(data[i]);\n        }\n      }\n\n      return array;\n  }\n\n  function onChange(cb){\n    if(typeof cb !== 'function'){\n      /* eslint no-console: 0 */\n      console.warn('onChange callback parameter must be a function!');\n      return;\n    }\n    callbacks.push(cb);\n    return function(){\n      callbacks.splice(callbacks.indexOf(cb), 1);\n    };\n  }\n\n  function triggerOnChange(eventName){\n    for (var i = 0; i < callbacks.length; i++) {\n      callbacks[i](eventName);\n    }\n  }\n\n  return arguments.length\n      ? add(arguments[0])\n      : crossfilter;\n}\n\n// Returns an array of size n, big enough to store ids up to m.\nfunction crossfilter_index(n, m) {\n  return (m < 0x101\n      ? xfilterArray.array8 : m < 0x10001\n      ? xfilterArray.array16\n      : xfilterArray.array32)(n);\n}\n\n// Constructs a new array of size n, with sequential values from 0 to n - 1.\nfunction crossfilter_range(n) {\n  var range = crossfilter_index(n, n);\n  for (var i = -1; ++i < n;) range[i] = i;\n  return range;\n}\n\nfunction crossfilter_capacity(w) {\n  return w === 8\n      ? 0x100 : w === 16\n      ? 0x10000\n      : 0x100000000;\n}\n","'use strict';\n\nfunction crossfilter_filterExact(bisect, value) {\n  return function(values) {\n    var n = values.length;\n    return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)];\n  };\n}\n\nfunction crossfilter_filterRange(bisect, range) {\n  var min = range[0],\n      max = range[1];\n  return function(values) {\n    var n = values.length;\n    return [bisect.left(values, min, 0, n), bisect.left(values, max, 0, n)];\n  };\n}\n\nfunction crossfilter_filterAll(values) {\n  return [0, values.length];\n}\n\nmodule.exports = {\n  filterExact: crossfilter_filterExact,\n  filterRange: crossfilter_filterRange,\n  filterAll: crossfilter_filterAll\n};\n","'use strict';\n\nvar crossfilter_identity = require('./identity');\n\nfunction heap_by(f) {\n\n  // Builds a binary heap within the specified array a[lo:hi]. The heap has the\n  // property such that the parent a[lo+i] is always less than or equal to its\n  // two children: a[lo+2*i+1] and a[lo+2*i+2].\n  function heap(a, lo, hi) {\n    var n = hi - lo,\n        i = (n >>> 1) + 1;\n    while (--i > 0) sift(a, i, n, lo);\n    return a;\n  }\n\n  // Sorts the specified array a[lo:hi] in descending order, assuming it is\n  // already a heap.\n  function sort(a, lo, hi) {\n    var n = hi - lo,\n        t;\n    while (--n > 0) t = a[lo], a[lo] = a[lo + n], a[lo + n] = t, sift(a, 1, n, lo);\n    return a;\n  }\n\n  // Sifts the element a[lo+i-1] down the heap, where the heap is the contiguous\n  // slice of array a[lo:lo+n]. This method can also be used to update the heap\n  // incrementally, without incurring the full cost of reconstructing the heap.\n  function sift(a, i, n, lo) {\n    var d = a[--lo + i],\n        x = f(d),\n        child;\n    while ((child = i << 1) <= n) {\n      if (child < n && f(a[lo + child]) > f(a[lo + child + 1])) child++;\n      if (x <= f(a[lo + child])) break;\n      a[lo + i] = a[lo + child];\n      i = child;\n    }\n    a[lo + i] = d;\n  }\n\n  heap.sort = sort;\n  return heap;\n}\n\nmodule.exports = heap_by(crossfilter_identity);\nmodule.exports.by = heap_by;\n","'use strict';\n\nvar crossfilter_identity = require('./identity');\nvar xFilterHeap = require('./heap');\n\nfunction heapselect_by(f) {\n  var heap = xFilterHeap.by(f);\n\n  // Returns a new array containing the top k elements in the array a[lo:hi].\n  // The returned array is not sorted, but maintains the heap property. If k is\n  // greater than hi - lo, then fewer than k elements will be returned. The\n  // order of elements in a is unchanged by this operation.\n  function heapselect(a, lo, hi, k) {\n    var queue = new Array(k = Math.min(hi - lo, k)),\n        min,\n        i,\n        d;\n\n    for (i = 0; i < k; ++i) queue[i] = a[lo++];\n    heap(queue, 0, k);\n\n    if (lo < hi) {\n      min = f(queue[0]);\n      do {\n        if (f(d = a[lo]) > min) {\n          queue[0] = d;\n          min = f(heap(queue, 0, k)[0]);\n        }\n      } while (++lo < hi);\n    }\n\n    return queue;\n  }\n\n  return heapselect;\n}\n\nmodule.exports = heapselect_by(crossfilter_identity);\nmodule.exports.by = heapselect_by; // assign the raw function to the export as well\n","'use strict';\n\nfunction crossfilter_identity(d) {\n  return d;\n}\n\nmodule.exports = crossfilter_identity;\n","'use strict';\n\nvar crossfilter_identity = require('./identity');\n\nfunction insertionsort_by(f) {\n\n  function insertionsort(a, lo, hi) {\n    for (var i = lo + 1; i < hi; ++i) {\n      for (var j = i, t = a[i], x = f(t); j > lo && f(a[j - 1]) > x; --j) {\n        a[j] = a[j - 1];\n      }\n      a[j] = t;\n    }\n    return a;\n  }\n\n  return insertionsort;\n}\n\nmodule.exports = insertionsort_by(crossfilter_identity);\nmodule.exports.by = insertionsort_by;\n","'use strict';\n\nfunction crossfilter_null() {\n  return null;\n}\n\nmodule.exports = crossfilter_null;\n","'use strict';\n\nfunction permute(array, index, deep) {\n  for (var i = 0, n = index.length, copy = deep ? JSON.parse(JSON.stringify(array)) : new Array(n); i < n; ++i) {\n    copy[i] = array[index[i]];\n  }\n  return copy;\n}\n\nmodule.exports = permute;\n","var crossfilter_identity = require('./identity');\nvar xFilterInsertionsort = require('./insertionsort');\n\n// Algorithm designed by Vladimir Yaroslavskiy.\n// Implementation based on the Dart project; see NOTICE and AUTHORS for details.\n\nfunction quicksort_by(f) {\n  var insertionsort = xFilterInsertionsort.by(f);\n\n  function sort(a, lo, hi) {\n    return (hi - lo < quicksort_sizeThreshold\n        ? insertionsort\n        : quicksort)(a, lo, hi);\n  }\n\n  function quicksort(a, lo, hi) {\n    // Compute the two pivots by looking at 5 elements.\n    var sixth = (hi - lo) / 6 | 0,\n        i1 = lo + sixth,\n        i5 = hi - 1 - sixth,\n        i3 = lo + hi - 1 >> 1,  // The midpoint.\n        i2 = i3 - sixth,\n        i4 = i3 + sixth;\n\n    var e1 = a[i1], x1 = f(e1),\n        e2 = a[i2], x2 = f(e2),\n        e3 = a[i3], x3 = f(e3),\n        e4 = a[i4], x4 = f(e4),\n        e5 = a[i5], x5 = f(e5);\n\n    var t;\n\n    // Sort the selected 5 elements using a sorting network.\n    if (x1 > x2) t = e1, e1 = e2, e2 = t, t = x1, x1 = x2, x2 = t;\n    if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;\n    if (x1 > x3) t = e1, e1 = e3, e3 = t, t = x1, x1 = x3, x3 = t;\n    if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;\n    if (x1 > x4) t = e1, e1 = e4, e4 = t, t = x1, x1 = x4, x4 = t;\n    if (x3 > x4) t = e3, e3 = e4, e4 = t, t = x3, x3 = x4, x4 = t;\n    if (x2 > x5) t = e2, e2 = e5, e5 = t, t = x2, x2 = x5, x5 = t;\n    if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;\n    if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;\n\n    var pivot1 = e2, pivotValue1 = x2,\n        pivot2 = e4, pivotValue2 = x4;\n\n    // e2 and e4 have been saved in the pivot variables. They will be written\n    // back, once the partitioning is finished.\n    a[i1] = e1;\n    a[i2] = a[lo];\n    a[i3] = e3;\n    a[i4] = a[hi - 1];\n    a[i5] = e5;\n\n    var less = lo + 1,   // First element in the middle partition.\n        great = hi - 2;  // Last element in the middle partition.\n\n    // Note that for value comparison, <, <=, >= and > coerce to a primitive via\n    // Object.prototype.valueOf; == and === do not, so in order to be consistent\n    // with natural order (such as for Date objects), we must do two compares.\n    var pivotsEqual = pivotValue1 <= pivotValue2 && pivotValue1 >= pivotValue2;\n    if (pivotsEqual) {\n\n      // Degenerated case where the partitioning becomes a dutch national flag\n      // problem.\n      //\n      // [ |  < pivot  | == pivot | unpartitioned | > pivot  | ]\n      //  ^             ^          ^             ^            ^\n      // left         less         k           great         right\n      //\n      // a[left] and a[right] are undefined and are filled after the\n      // partitioning.\n      //\n      // Invariants:\n      //   1) for x in ]left, less[ : x < pivot.\n      //   2) for x in [less, k[ : x == pivot.\n      //   3) for x in ]great, right[ : x > pivot.\n      for (var k = less; k <= great; ++k) {\n        var ek = a[k], xk = f(ek);\n        if (xk < pivotValue1) {\n          if (k !== less) {\n            a[k] = a[less];\n            a[less] = ek;\n          }\n          ++less;\n        } else if (xk > pivotValue1) {\n\n          // Find the first element <= pivot in the range [k - 1, great] and\n          // put [:ek:] there. We know that such an element must exist:\n          // When k == less, then el3 (which is equal to pivot) lies in the\n          // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.\n          // Note that in the latter case invariant 2 will be violated for a\n          // short amount of time. The invariant will be restored when the\n          // pivots are put into their final positions.\n          /* eslint no-constant-condition: 0 */\n          while (true) {\n            var greatValue = f(a[great]);\n            if (greatValue > pivotValue1) {\n              great--;\n              // This is the only location in the while-loop where a new\n              // iteration is started.\n              continue;\n            } else if (greatValue < pivotValue1) {\n              // Triple exchange.\n              a[k] = a[less];\n              a[less++] = a[great];\n              a[great--] = ek;\n              break;\n            } else {\n              a[k] = a[great];\n              a[great--] = ek;\n              // Note: if great < k then we will exit the outer loop and fix\n              // invariant 2 (which we just violated).\n              break;\n            }\n          }\n        }\n      }\n    } else {\n\n      // We partition the list into three parts:\n      //  1. < pivot1\n      //  2. >= pivot1 && <= pivot2\n      //  3. > pivot2\n      //\n      // During the loop we have:\n      // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned  | > pivot2  | ]\n      //  ^            ^                        ^              ^             ^\n      // left         less                     k              great        right\n      //\n      // a[left] and a[right] are undefined and are filled after the\n      // partitioning.\n      //\n      // Invariants:\n      //   1. for x in ]left, less[ : x < pivot1\n      //   2. for x in [less, k[ : pivot1 <= x && x <= pivot2\n      //   3. for x in ]great, right[ : x > pivot2\n      (function () { // isolate scope\n      for (var k = less; k <= great; k++) {\n        var ek = a[k], xk = f(ek);\n        if (xk < pivotValue1) {\n          if (k !== less) {\n            a[k] = a[less];\n            a[less] = ek;\n          }\n          ++less;\n        } else {\n          if (xk > pivotValue2) {\n            while (true) {\n              var greatValue = f(a[great]);\n              if (greatValue > pivotValue2) {\n                great--;\n                if (great < k) break;\n                // This is the only location inside the loop where a new\n                // iteration is started.\n                continue;\n              } else {\n                // a[great] <= pivot2.\n                if (greatValue < pivotValue1) {\n                  // Triple exchange.\n                  a[k] = a[less];\n                  a[less++] = a[great];\n                  a[great--] = ek;\n                } else {\n                  // a[great] >= pivot1.\n                  a[k] = a[great];\n                  a[great--] = ek;\n                }\n                break;\n              }\n            }\n          }\n        }\n      }\n      })(); // isolate scope\n    }\n\n    // Move pivots into their final positions.\n    // We shrunk the list from both sides (a[left] and a[right] have\n    // meaningless values in them) and now we move elements from the first\n    // and third partition into these locations so that we can store the\n    // pivots.\n    a[lo] = a[less - 1];\n    a[less - 1] = pivot1;\n    a[hi - 1] = a[great + 1];\n    a[great + 1] = pivot2;\n\n    // The list is now partitioned into three partitions:\n    // [ < pivot1   | >= pivot1 && <= pivot2   |  > pivot2   ]\n    //  ^            ^                        ^             ^\n    // left         less                     great        right\n\n    // Recursive descent. (Don't include the pivot values.)\n    sort(a, lo, less - 1);\n    sort(a, great + 2, hi);\n\n    if (pivotsEqual) {\n      // All elements in the second partition are equal to the pivot. No\n      // need to sort them.\n      return a;\n    }\n\n    // In theory it should be enough to call _doSort recursively on the second\n    // partition.\n    // The Android source however removes the pivot elements from the recursive\n    // call if the second partition is too large (more than 2/3 of the list).\n    if (less < i1 && great > i5) {\n\n      (function () { // isolate scope\n      var lessValue, greatValue;\n      while ((lessValue = f(a[less])) <= pivotValue1 && lessValue >= pivotValue1) ++less;\n      while ((greatValue = f(a[great])) <= pivotValue2 && greatValue >= pivotValue2) --great;\n\n      // Copy paste of the previous 3-way partitioning with adaptions.\n      //\n      // We partition the list into three parts:\n      //  1. == pivot1\n      //  2. > pivot1 && < pivot2\n      //  3. == pivot2\n      //\n      // During the loop we have:\n      // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned  | == pivot2 ]\n      //              ^                      ^              ^\n      //            less                     k              great\n      //\n      // Invariants:\n      //   1. for x in [ *, less[ : x == pivot1\n      //   2. for x in [less, k[ : pivot1 < x && x < pivot2\n      //   3. for x in ]great, * ] : x == pivot2\n      for (var k = less; k <= great; k++) {\n        var ek = a[k], xk = f(ek);\n        if (xk <= pivotValue1 && xk >= pivotValue1) {\n          if (k !== less) {\n            a[k] = a[less];\n            a[less] = ek;\n          }\n          less++;\n        } else {\n          if (xk <= pivotValue2 && xk >= pivotValue2) {\n            /* eslint no-constant-condition: 0 */\n            while (true) {\n              greatValue = f(a[great]);\n              if (greatValue <= pivotValue2 && greatValue >= pivotValue2) {\n                great--;\n                if (great < k) break;\n                // This is the only location inside the loop where a new\n                // iteration is started.\n                continue;\n              } else {\n                // a[great] < pivot2.\n                if (greatValue < pivotValue1) {\n                  // Triple exchange.\n                  a[k] = a[less];\n                  a[less++] = a[great];\n                  a[great--] = ek;\n                } else {\n                  // a[great] == pivot1.\n                  a[k] = a[great];\n                  a[great--] = ek;\n                }\n                break;\n              }\n            }\n          }\n        }\n      }\n      })(); // isolate scope\n\n    }\n\n    // The second partition has now been cleared of pivot elements and looks\n    // as follows:\n    // [  *  |  > pivot1 && < pivot2  | * ]\n    //        ^                      ^\n    //       less                  great\n    // Sort the second partition using recursive descent.\n\n    // The second partition looks as follows:\n    // [  *  |  >= pivot1 && <= pivot2  | * ]\n    //        ^                        ^\n    //       less                    great\n    // Simply sort it by recursive descent.\n\n    return sort(a, less, great + 1);\n  }\n\n  return sort;\n}\n\nvar quicksort_sizeThreshold = 32;\n\nmodule.exports = quicksort_by(crossfilter_identity);\nmodule.exports.by = quicksort_by;\n","'use strict';\n\nfunction crossfilter_reduceIncrement(p) {\n  return p + 1;\n}\n\nfunction crossfilter_reduceDecrement(p) {\n  return p - 1;\n}\n\nfunction crossfilter_reduceAdd(f) {\n  return function(p, v) {\n    return p + +f(v);\n  };\n}\n\nfunction crossfilter_reduceSubtract(f) {\n  return function(p, v) {\n    return p - f(v);\n  };\n}\n\nmodule.exports = {\n  reduceIncrement: crossfilter_reduceIncrement,\n  reduceDecrement: crossfilter_reduceDecrement,\n  reduceAdd: crossfilter_reduceAdd,\n  reduceSubtract: crossfilter_reduceSubtract\n};\n","'use strict';\n\nfunction crossfilter_zero() {\n  return 0;\n}\n\nmodule.exports = crossfilter_zero;\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    symbolTag = '[object Symbol]';\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/,\n    reLeadingDot = /^\\./,\n    rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n    splice = arrayProto.splice;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  return this.has(key) && delete this.__data__[key];\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value) {\n  return isArray(value) ? value : stringToPath(value);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoize(function(string) {\n  string = toString(string);\n\n  var result = [];\n  if (reLeadingDot.test(string)) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, string) {\n    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result);\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Assign cache to `_.memoize`.\nmemoize.Cache = MapCache;\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\n/**\n * This method is like `_.get` except that if the resolved value is a\n * function it's invoked with the `this` binding of its parent object and\n * its result is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to resolve.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n *\n * _.result(object, 'a[0].b.c1');\n * // => 3\n *\n * _.result(object, 'a[0].b.c2');\n * // => 4\n *\n * _.result(object, 'a[0].b.c3', 'default');\n * // => 'default'\n *\n * _.result(object, 'a[0].b.c3', _.constant('default'));\n * // => 'default'\n */\nfunction result(object, path, defaultValue) {\n  path = isKey(path, object) ? [path] : castPath(path);\n\n  var index = -1,\n      length = path.length;\n\n  // Ensure the loop is entered when path is empty.\n  if (!length) {\n    object = undefined;\n    length = 1;\n  }\n  while (++index < length) {\n    var value = object == null ? undefined : object[toKey(path[index])];\n    if (value === undefined) {\n      index = length;\n      value = defaultValue;\n    }\n    object = isFunction(value) ? value.call(object) : value;\n  }\n  return object;\n}\n\nmodule.exports = result;\n","var reductio_parameters = require('./parameters.js');\n\n_assign = function assign(target) {\n\tif (target == null) {\n\t\tthrow new TypeError('Cannot convert undefined or null to object');\n\t}\n\n\tvar output = Object(target);\n\tfor (var index = 1; index < arguments.length; ++index) {\n\t\tvar source = arguments[index];\n\t\tif (source != null) {\n\t\t\tfor (var nextKey in source) {\n\t\t\t\tif(source.hasOwnProperty(nextKey)) {\n\t\t\t\t\toutput[nextKey] = source[nextKey];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn output;\n};\n\nfunction accessor_build(obj, p) {\n\t// obj.order = function(value) {\n\t// \tif (!arguments.length) return p.order;\n\t// \tp.order = value;\n\t// \treturn obj;\n\t// };\n\n\t// Converts a string to an accessor function\n\tfunction accessorify(v) {\n\t\tif( typeof v === 'string' ) {\n\t\t\t// Rewrite to a function\n\t\t\tvar tempValue = v;\n\t\t\tvar func = function (d) { return d[tempValue]; }\n\t\t\treturn func;\n\t\t} else {\n\t\t\treturn v;\n\t\t}\n\t}\n\n\t// Converts a string to an accessor function\n\tfunction accessorifyNumeric(v) {\n\t\tif( typeof v === 'string' ) {\n\t\t\t// Rewrite to a function\n\t\t\tvar tempValue = v;\n\t\t\tvar func = function (d) { return +d[tempValue]; }\n\t\t\treturn func;\n\t\t} else {\n\t\t\treturn v;\n\t\t}\n\t}\n\n\tobj.fromObject = function(value) {\n\t\tif(!arguments.length) return p;\n\t\t_assign(p, value);\n\t\treturn obj;\n\t};\n\n\tobj.toObject = function() {\n\t\treturn p;\n\t};\n\n\tobj.count = function(value, propName) {\n\t\tif (!arguments.length) return p.count;\n    if (!propName) {\n      propName = 'count';\n    }\n\t\tp.count = propName;\n\t\treturn obj;\n\t};\n\n\tobj.sum = function(value) {\n\t\tif (!arguments.length) return p.sum;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tp.sum = value;\n\t\treturn obj;\n\t};\n\n\tobj.avg = function(value) {\n\t\tif (!arguments.length) return p.avg;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\t// We can take an accessor function, a boolean, or a string\n\t\tif( typeof value === 'function' ) {\n\t\t\tif(p.sum && p.sum !== value) console.warn('SUM aggregation is being overwritten by AVG aggregation');\n\t\t\tp.sum = value;\n\t\t\tp.avg = true;\n\t\t\tp.count = 'count';\n\t\t} else {\n\t\t\tp.avg = value;\n\t\t}\n\t\treturn obj;\n\t};\n\n\tobj.exception = function(value) {\n\t\tif (!arguments.length) return p.exceptionAccessor;\n\n\t\tvalue = accessorify(value);\n\n\t\tp.exceptionAccessor = value;\n\t\treturn obj;\n\t};\n\n\tobj.filter = function(value) {\n\t\tif (!arguments.length) return p.filter;\n\t\tp.filter = value;\n\t\treturn obj;\n\t};\n\n\tobj.valueList = function(value) {\n\t\tif (!arguments.length) return p.valueList;\n\n\t\tvalue = accessorify(value);\n\n\t\tp.valueList = value;\n\t\treturn obj;\n\t};\n\n\tobj.median = function(value) {\n\t\tif (!arguments.length) return p.median;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tif(typeof value === 'function') {\n\t\t\tif(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by median aggregation');\n\t\t\tp.valueList = value;\n\t\t}\n\t\tp.median = value;\n\t\treturn obj;\n\t};\n\n\tobj.min = function(value) {\n\t\tif (!arguments.length) return p.min;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tif(typeof value === 'function') {\n\t\t\tif(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by min aggregation');\n\t\t\tp.valueList = value;\n\t\t}\n\t\tp.min = value;\n\t\treturn obj;\n\t};\n\n\tobj.max = function(value) {\n\t\tif (!arguments.length) return p.max;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tif(typeof value === 'function') {\n\t\t\tif(p.valueList && p.valueList !== value) console.warn('VALUELIST accessor is being overwritten by max aggregation');\n\t\t\tp.valueList = value;\n\t\t}\n\t\tp.max = value;\n\t\treturn obj;\n\t};\n\n\tobj.exceptionCount = function(value) {\n\t\tif (!arguments.length) return p.exceptionCount;\n\n\t\tvalue = accessorify(value);\n\n\t\tif( typeof value === 'function' ) {\n\t\t\tif(p.exceptionAccessor && p.exceptionAccessor !== value) console.warn('EXCEPTION accessor is being overwritten by exception count aggregation');\n\t\t\tp.exceptionAccessor = value;\n\t\t\tp.exceptionCount = true;\n\t\t} else {\n\t\t\tp.exceptionCount = value;\n\t\t}\n\t\treturn obj;\n\t};\n\n\tobj.exceptionSum = function(value) {\n\t\tif (!arguments.length) return p.exceptionSum;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tp.exceptionSum = value;\n\t\treturn obj;\n\t};\n\n\tobj.histogramValue = function(value) {\n\t\tif (!arguments.length) return p.histogramValue;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tp.histogramValue = value;\n\t\treturn obj;\n\t};\n\n\tobj.histogramBins = function(value) {\n\t\tif (!arguments.length) return p.histogramThresholds;\n\t\tp.histogramThresholds = value;\n\t\treturn obj;\n\t};\n\n\tobj.std = function(value) {\n\t\tif (!arguments.length) return p.std;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tif(typeof(value) === 'function') {\n\t\t\tp.sumOfSquares = value;\n\t\t\tp.sum = value;\n\t\t\tp.count = 'count';\n\t\t\tp.std = true;\n\t\t} else {\n\t\t\tp.std = value;\n\t\t}\n\t\treturn obj;\n\t};\n\n\tobj.sumOfSq = function(value) {\n\t\tif (!arguments.length) return p.sumOfSquares;\n\n\t\tvalue = accessorifyNumeric(value);\n\n\t\tp.sumOfSquares = value;\n\t\treturn obj;\n\t};\n\n\tobj.value = function(value, accessor) {\n\t\tif (!arguments.length || typeof value !== 'string' ) {\n\t\t\tconsole.error(\"'value' requires a string argument.\");\n\t\t} else {\n\t\t\tif(!p.values) p.values = {};\n\t\t\tp.values[value] = {};\n\t\t\tp.values[value].parameters = reductio_parameters();\n\t\t\taccessor_build(p.values[value], p.values[value].parameters);\n\t\t\tif(accessor) p.values[value].accessor = accessor;\n\t\t\treturn p.values[value];\n\t\t}\n\t};\n\n\tobj.nest = function(keyAccessorArray) {\n\t\tif(!arguments.length) return p.nestKeys;\n\n\t\tkeyAccessorArray.map(accessorify);\n\n\t\tp.nestKeys = keyAccessorArray;\n\t\treturn obj;\n\t};\n\n\tobj.alias = function(propAccessorObj) {\n\t\tif(!arguments.length) return p.aliasKeys;\n\t\tp.aliasKeys = propAccessorObj;\n\t\treturn obj;\n\t};\n\n\tobj.aliasProp = function(propAccessorObj) {\n\t\tif(!arguments.length) return p.aliasPropKeys;\n\t\tp.aliasPropKeys = propAccessorObj;\n\t\treturn obj;\n\t};\n\n\tobj.groupAll = function(groupTest) {\n\t\tif(!arguments.length) return p.groupAll;\n\t\tp.groupAll = groupTest;\n\t\treturn obj;\n\t};\n\n\tobj.dataList = function(value) {\n\t\tif (!arguments.length) return p.dataList;\n\t\tp.dataList = value;\n\t\treturn obj;\n\t};\n\n\tobj.custom = function(addRemoveInitialObj) {\n\t\tif (!arguments.length) return p.custom;\n\t\tp.custom = addRemoveInitialObj;\n\t\treturn obj;\n\t};\n\n}\n\nvar reductio_accessors = {\n\tbuild: accessor_build\n};\n\nmodule.exports = reductio_accessors;\n","var reductio_alias = {\n\tinitial: function(prior, path, obj) {\n\t\treturn function (p) {\n\t\t\tif(prior) p = prior(p);\n\t\t\tfunction buildAliasFunction(key){\n\t\t\t\treturn function(){\n\t\t\t\t\treturn obj[key](path(p));\n\t\t\t\t};\n\t\t\t}\n\t\t\tfor(var prop in obj) {\n\t\t\t\tpath(p)[prop] = buildAliasFunction(prop);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_alias;","var reductio_alias_prop = {\n\tadd: function (obj, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tfor(var prop in obj) {\n\t\t\t\tpath(p)[prop] = obj[prop](path(p),v);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_alias_prop;","var reductio_avg = {\n\tadd: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tif(path(p).count > 0) {\n\t\t\t\tpath(p).avg = path(p).sum / path(p).count;\n\t\t\t} else {\n\t\t\t\tpath(p).avg = 0;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tif(path(p).count > 0) {\n\t\t\t\tpath(p).avg = path(p).sum / path(p).count;\n\t\t\t} else {\n\t\t\t\tpath(p).avg = 0;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).avg = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_avg;","var reductio_filter = require('./filter.js');\nvar reductio_count = require('./count.js');\nvar reductio_sum = require('./sum.js');\nvar reductio_avg = require('./avg.js');\nvar reductio_median = require('./median.js');\nvar reductio_min = require('./min.js');\nvar reductio_max = require('./max.js');\nvar reductio_value_count = require('./value-count.js');\nvar reductio_value_list = require('./value-list.js');\nvar reductio_exception_count = require('./exception-count.js');\nvar reductio_exception_sum = require('./exception-sum.js');\nvar reductio_histogram = require('./histogram.js');\nvar reductio_sum_of_sq = require('./sum-of-squares.js');\nvar reductio_std = require('./std.js');\nvar reductio_nest = require('./nest.js');\nvar reductio_alias = require('./alias.js');\nvar reductio_alias_prop = require('./aliasProp.js');\nvar reductio_data_list = require('./data-list.js');\nvar reductio_custom = require('./custom.js');\n\nfunction build_function(p, f, path) {\n\t// We have to build these functions in order. Eventually we can include dependency\n\t// information and create a dependency graph if the process becomes complex enough.\n\n\tif(!path) path = function (d) { return d; };\n\n\t// Keep track of the original reducers so that filtering can skip back to\n\t// them if this particular value is filtered out.\n\tvar origF = {\n\t\treduceAdd: f.reduceAdd,\n\t\treduceRemove: f.reduceRemove,\n\t\treduceInitial: f.reduceInitial\n\t};\n\n\tif(p.count || p.std) {\n    f.reduceAdd = reductio_count.add(f.reduceAdd, path, p.count);\n    f.reduceRemove = reductio_count.remove(f.reduceRemove, path, p.count);\n    f.reduceInitial = reductio_count.initial(f.reduceInitial, path, p.count);\n\t}\n\n\tif(p.sum) {\n\t\tf.reduceAdd = reductio_sum.add(p.sum, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_sum.remove(p.sum, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_sum.initial(f.reduceInitial, path);\n\t}\n\n\tif(p.avg) {\n\t\tif(!p.count || !p.sum) {\n\t\t\tconsole.error(\"You must set .count(true) and define a .sum(accessor) to use .avg(true).\");\n\t\t} else {\n\t\t\tf.reduceAdd = reductio_avg.add(p.sum, f.reduceAdd, path);\n\t\t\tf.reduceRemove = reductio_avg.remove(p.sum, f.reduceRemove, path);\n\t\t\tf.reduceInitial = reductio_avg.initial(f.reduceInitial, path);\n\t\t}\n\t}\n\n\t// The unique-only reducers come before the value_count reducers. They need to check if\n\t// the value is already in the values array on the group. They should only increment/decrement\n\t// counts if the value not in the array or the count on the value is 0.\n\tif(p.exceptionCount) {\n\t\tif(!p.exceptionAccessor) {\n\t\t\tconsole.error(\"You must define an .exception(accessor) to use .exceptionCount(true).\");\n\t\t} else {\n\t\t\tf.reduceAdd = reductio_exception_count.add(p.exceptionAccessor, f.reduceAdd, path);\n\t\t\tf.reduceRemove = reductio_exception_count.remove(p.exceptionAccessor, f.reduceRemove, path);\n\t\t\tf.reduceInitial = reductio_exception_count.initial(f.reduceInitial, path);\n\t\t}\n\t}\n\n\tif(p.exceptionSum) {\n\t\tif(!p.exceptionAccessor) {\n\t\t\tconsole.error(\"You must define an .exception(accessor) to use .exceptionSum(accessor).\");\n\t\t} else {\n\t\t\tf.reduceAdd = reductio_exception_sum.add(p.exceptionAccessor, p.exceptionSum, f.reduceAdd, path);\n\t\t\tf.reduceRemove = reductio_exception_sum.remove(p.exceptionAccessor, p.exceptionSum, f.reduceRemove, path);\n\t\t\tf.reduceInitial = reductio_exception_sum.initial(f.reduceInitial, path);\n\t\t}\n\t}\n\n\t// Maintain the values array.\n\tif(p.valueList || p.median || p.min || p.max) {\n\t\tf.reduceAdd = reductio_value_list.add(p.valueList, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_value_list.remove(p.valueList, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_value_list.initial(f.reduceInitial, path);\n\t}\n\n\t// Maintain the data array.\n\tif(p.dataList) {\n\t\tf.reduceAdd = reductio_data_list.add(p.dataList, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_data_list.remove(p.dataList, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_data_list.initial(f.reduceInitial, path);\n\t}\n\n\tif(p.median) {\n\t\tf.reduceAdd = reductio_median.add(f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_median.remove(f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_median.initial(f.reduceInitial, path);\n\t}\n\n\tif(p.min) {\n\t\tf.reduceAdd = reductio_min.add(f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_min.remove(f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_min.initial(f.reduceInitial, path);\n\t}\n\n\tif(p.max) {\n\t\tf.reduceAdd = reductio_max.add(f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_max.remove(f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_max.initial(f.reduceInitial, path);\n\t}\n\n\t// Maintain the values count array.\n\tif(p.exceptionAccessor) {\n\t\tf.reduceAdd = reductio_value_count.add(p.exceptionAccessor, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_value_count.remove(p.exceptionAccessor, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_value_count.initial(f.reduceInitial, path);\n\t}\n\n\t// Histogram\n\tif(p.histogramValue && p.histogramThresholds) {\n\t\tf.reduceAdd = reductio_histogram.add(p.histogramValue, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_histogram.remove(p.histogramValue, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_histogram.initial(p.histogramThresholds ,f.reduceInitial, path);\n\t}\n\n\t// Sum of Squares\n\tif(p.sumOfSquares) {\n\t\tf.reduceAdd = reductio_sum_of_sq.add(p.sumOfSquares, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_sum_of_sq.remove(p.sumOfSquares, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_sum_of_sq.initial(f.reduceInitial, path);\n\t}\n\n\t// Standard deviation\n\tif(p.std) {\n\t\tif(!p.sumOfSquares || !p.sum) {\n\t\t\tconsole.error(\"You must set .sumOfSq(accessor) and define a .sum(accessor) to use .std(true). Or use .std(accessor).\");\n\t\t} else {\n\t\t\tf.reduceAdd = reductio_std.add(f.reduceAdd, path);\n\t\t\tf.reduceRemove = reductio_std.remove(f.reduceRemove, path);\n\t\t\tf.reduceInitial = reductio_std.initial(f.reduceInitial, path);\n\t\t}\n\t}\n\n\t// Custom reducer defined by 3 functions : add, remove, initial\n\tif (p.custom) {\n\t\tf.reduceAdd = reductio_custom.add(f.reduceAdd, path, p.custom.add);\n\t\tf.reduceRemove = reductio_custom.remove(f.reduceRemove, path, p.custom.remove);\n\t\tf.reduceInitial = reductio_custom.initial(f.reduceInitial, path, p.custom.initial);\n\t}\n\n\t// Nesting\n\tif(p.nestKeys) {\n\t\tf.reduceAdd = reductio_nest.add(p.nestKeys, f.reduceAdd, path);\n\t\tf.reduceRemove = reductio_nest.remove(p.nestKeys, f.reduceRemove, path);\n\t\tf.reduceInitial = reductio_nest.initial(f.reduceInitial, path);\n\t}\n\n\t// Alias functions\n\tif(p.aliasKeys) {\n\t\tf.reduceInitial = reductio_alias.initial(f.reduceInitial, path, p.aliasKeys);\n\t}\n\n\t// Alias properties - this is less efficient than alias functions\n\tif(p.aliasPropKeys) {\n\t\tf.reduceAdd = reductio_alias_prop.add(p.aliasPropKeys, f.reduceAdd, path);\n\t\t// This isn't a typo. The function is the same for add/remove.\n\t\tf.reduceRemove = reductio_alias_prop.add(p.aliasPropKeys, f.reduceRemove, path);\n\t}\n\n\t// Filters determine if our built-up priors should run, or if it should skip\n\t// back to the filters given at the beginning of this build function.\n\tif (p.filter) {\n\t\tf.reduceAdd = reductio_filter.add(p.filter, f.reduceAdd, origF.reduceAdd, path);\n\t\tf.reduceRemove = reductio_filter.remove(p.filter, f.reduceRemove, origF.reduceRemove, path);\n\t}\n\n\t// Values go last.\n\tif(p.values) {\n\t\tObject.getOwnPropertyNames(p.values).forEach(function(n) {\n\t\t\t// Set up the path on each group.\n\t\t\tvar setupPath = function(prior) {\n\t\t\t\treturn function (p) {\n\t\t\t\t\tp = prior(p);\n\t\t\t\t\tpath(p)[n] = {};\n\t\t\t\t\treturn p;\n\t\t\t\t};\n\t\t\t};\n\t\t\tf.reduceInitial = setupPath(f.reduceInitial);\n\t\t\tbuild_function(p.values[n].parameters, f, function (p) { return p[n]; });\n\t\t});\n\t}\n}\n\nvar reductio_build = {\n\tbuild: build_function\n};\n\nmodule.exports = reductio_build;\n","var pluck = function(n){\n    return function(d){\n        return d[n];\n    };\n};\n\n// supported operators are sum, avg, and count\n_grouper = function(path, prior){\n    if(!path) path = function(d){return d;};\n    return function(p, v){\n        if(prior) prior(p, v);\n        var x = path(p), y = path(v);\n        if(typeof y.count !== 'undefined') x.count += y.count;\n        if(typeof y.sum !== 'undefined') x.sum += y.sum;\n        if(typeof y.avg !== 'undefined') x.avg = x.sum/x.count;\n        return p;\n    };\n};\n\nreductio_cap = function (prior, f, p) {\n    var obj = f.reduceInitial();\n    // we want to support values so we'll need to know what those are\n    var values = p.values ? Object.keys(p.values) : [];\n    var _othersGrouper = _grouper();\n    if (values.length) {\n        for (var i = 0; i < values.length; ++i) {\n            _othersGrouper = _grouper(pluck(values[i]), _othersGrouper);\n        }\n    }\n    return function (cap, othersName) {\n        if (!arguments.length) return prior();\n        if( cap === Infinity || !cap ) return prior();\n        var all = prior();\n        var slice_idx = cap-1;\n        if(all.length <= cap) return all;\n        var data = all.slice(0, slice_idx);\n        var others = {key: othersName || 'Others'};\n        others.value = f.reduceInitial();\n        for (var i = slice_idx; i < all.length; ++i) {\n            _othersGrouper(others.value, all[i].value);\n        }\n        data.push(others);\n        return data;\n    };\n};\n\nmodule.exports = reductio_cap;\n","var reductio_count = {\n\tadd: function(prior, path, propName) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p)[propName]++;\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function(prior, path, propName) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p)[propName]--;\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function(prior, path, propName) {\n\t\treturn function (p) {\n\t\t\tif(prior) p = prior(p);\n\t\t\t// if(p === undefined) p = {};\n\t\t\tpath(p)[propName] = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_count;","var reductio_custom = {\n\tadd: function(prior, path, addFn) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\treturn addFn(p, v);\n\t\t};\n\t},\n\tremove: function(prior, path, removeFn) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\treturn removeFn(p, v);\n\t\t};\n\t},\n\tinitial: function(prior, path, initialFn) {\n\t\treturn function (p) {\t\n\t\t\tif(prior) p = prior(p);\n\t\t\treturn initialFn(p);\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_custom;","var reductio_data_list = {\n\tadd: function(a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).dataList.push(v);\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function(a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).dataList.splice(path(p).dataList.indexOf(v), 1);\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function(prior, path) {\n\t\treturn function (p) {\n\t\t\tif(prior) p = prior(p);\n\t\t\tpath(p).dataList = [];\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_data_list;\n","var reductio_exception_count = {\n\tadd: function (a, prior, path) {\n\t\tvar i, curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Only count++ if the p.values array doesn't contain a(v) or if it's 0.\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\tcurr = path(p).values[i];\n\t\t\tif((!curr || curr[0] !== a(v)) || curr[1] === 0) {\n\t\t\t\tpath(p).exceptionCount++;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\tvar i, curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Only count-- if the p.values array contains a(v) value of 1.\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\tcurr = path(p).values[i];\n\t\t\tif(curr && curr[0] === a(v) && curr[1] === 1) {\n\t\t\t\tpath(p).exceptionCount--;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).exceptionCount = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_exception_count;","var reductio_exception_sum = {\n\tadd: function (a, sum, prior, path) {\n\t\tvar i, curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Only sum if the p.values array doesn't contain a(v) or if it's 0.\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\tcurr = path(p).values[i];\n\t\t\tif((!curr || curr[0] !== a(v)) || curr[1] === 0) {\n\t\t\t\tpath(p).exceptionSum = path(p).exceptionSum + sum(v);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, sum, prior, path) {\n\t\tvar i, curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Only sum if the p.values array contains a(v) value of 1.\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\tcurr = path(p).values[i];\n\t\t\tif(curr && curr[0] === a(v) && curr[1] === 1) {\n\t\t\t\tpath(p).exceptionSum = path(p).exceptionSum - sum(v);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).exceptionSum = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_exception_sum;","var reductio_filter = {\n\t// The big idea here is that you give us a filter function to run on values,\n\t// a 'prior' reducer to run (just like the rest of the standard reducers),\n\t// and a reference to the last reducer (called 'skip' below) defined before\n\t// the most recent chain of reducers.  This supports individual filters for\n\t// each .value('...') chain that you add to your reducer.\n\tadd: function (filter, prior, skip) {\n\t\treturn function (p, v, nf) {\n\t\t\tif (filter(v, nf)) {\n\t\t\t\tif (prior) prior(p, v, nf);\n\t\t\t} else {\n\t\t\t\tif (skip) skip(p, v, nf);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (filter, prior, skip) {\n\t\treturn function (p, v, nf) {\n\t\t\tif (filter(v, nf)) {\n\t\t\t\tif (prior) prior(p, v, nf);\n\t\t\t} else {\n\t\t\t\tif (skip) skip(p, v, nf);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_filter;\n","var crossfilter = require('crossfilter2');\n\nvar reductio_histogram = {\n\tadd: function (a, prior, path) {\n\t\tvar bisect = crossfilter.bisect.by(function(d) { return d; }).left;\n\t\tvar bisectHisto = crossfilter.bisect.by(function(d) { return d.x; }).right;\n\t\tvar curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tcurr = path(p).histogram[bisectHisto(path(p).histogram, a(v), 0, path(p).histogram.length) - 1];\n\t\t\tcurr.y++;\n\t\t\tcurr.splice(bisect(curr, a(v), 0, curr.length), 0, a(v));\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\tvar bisect = crossfilter.bisect.by(function(d) { return d; }).left;\n\t\tvar bisectHisto = crossfilter.bisect.by(function(d) { return d.x; }).right;\n\t\tvar curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tcurr = path(p).histogram[bisectHisto(path(p).histogram, a(v), 0, path(p).histogram.length) - 1];\n\t\t\tcurr.y--;\n\t\t\tcurr.splice(bisect(curr, a(v), 0, curr.length), 1);\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (thresholds, prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).histogram = [];\n\t\t\tvar arr = [];\n\t\t\tfor(var i = 1; i < thresholds.length; i++) {\n\t\t\t\tarr = [];\n\t\t\t\tarr.x = thresholds[i - 1];\n\t\t\t\tarr.dx = (thresholds[i] - thresholds[i - 1]);\n\t\t\t\tarr.y = 0;\n\t\t\t\tpath(p).histogram.push(arr);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_histogram;","var reductio_max = {\n\tadd: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n \n\t\t\tpath(p).max = path(p).valueList[path(p).valueList.length - 1];\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\t// Check for undefined.\n\t\t\tif(path(p).valueList.length === 0) {\n\t\t\t\tpath(p).max = undefined;\n\t\t\t\treturn p;\n\t\t\t}\n \n\t\t\tpath(p).max = path(p).valueList[path(p).valueList.length - 1];\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).max = undefined;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_max;","var reductio_median = {\n\tadd: function (prior, path) {\n\t\tvar half;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\thalf = Math.floor(path(p).valueList.length/2);\n \n\t\t\tif(path(p).valueList.length % 2) {\n\t\t\t\tpath(p).median = path(p).valueList[half];\n\t\t\t} else {\n\t\t\t\tpath(p).median = (path(p).valueList[half-1] + path(p).valueList[half]) / 2.0;\n\t\t\t}\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (prior, path) {\n\t\tvar half;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\thalf = Math.floor(path(p).valueList.length/2);\n\n\t\t\t// Check for undefined.\n\t\t\tif(path(p).valueList.length === 0) {\n\t\t\t\tpath(p).median = undefined;\n\t\t\t\treturn p;\n\t\t\t}\n \n\t\t\tif(path(p).valueList.length === 1 || path(p).valueList.length % 2) {\n\t\t\t\tpath(p).median = path(p).valueList[half];\n\t\t\t} else {\n\t\t\t\tpath(p).median = (path(p).valueList[half-1] + path(p).valueList[half]) / 2.0;\n\t\t\t}\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).median = undefined;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_median;","var reductio_min = {\n\tadd: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n \n\t\t\tpath(p).min = path(p).valueList[0];\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\t// Check for undefined.\n\t\t\tif(path(p).valueList.length === 0) {\n\t\t\t\tpath(p).min = undefined;\n\t\t\t\treturn p;\n\t\t\t}\n \n\t\t\tpath(p).min = path(p).valueList[0];\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).min = undefined;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_min;","var crossfilter = require('crossfilter2');\n\nvar reductio_nest = {\n\tadd: function (keyAccessors, prior, path) {\n\t\tvar i; // Current key accessor\n\t\tvar arrRef;\n\t\tvar newRef;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\tarrRef = path(p).nest;\n\t\t\tkeyAccessors.forEach(function(a) {\n\t\t\t\tnewRef = arrRef.filter(function(d) { return d.key === a(v); })[0];\n\t\t\t\tif(newRef) {\n\t\t\t\t\t// There is another level.\n\t\t\t\t\tarrRef = newRef.values;\n\t\t\t\t} else {\n\t\t\t\t\t// Next level doesn't yet exist so we create it.\n\t\t\t\t\tnewRef = [];\n\t\t\t\t\tarrRef.push({ key: a(v), values: newRef });\n\t\t\t\t\tarrRef = newRef;\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tarrRef.push(v);\n\t\t\t\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (keyAccessors, prior, path) {\n\t\tvar arrRef;\n\t\tvar nextRef;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\n\t\t\tarrRef = path(p).nest;\n\t\t\tkeyAccessors.forEach(function(a) {\n\t\t\t\tarrRef = arrRef.filter(function(d) { return d.key === a(v); })[0].values;\n\t\t\t});\n\n\t\t\t// Array contains an actual reference to the row, so just splice it out.\n\t\t\tarrRef.splice(arrRef.indexOf(v), 1);\n\n\t\t\t// If the leaf now has length 0 and it's not the base array remove it.\n\t\t\t// TODO\n\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).nest = [];\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_nest;","var reductio_parameters = function() {\n\treturn {\n\t\torder: false,\n\t\tavg: false,\n\t\tcount: false,\n\t\tsum: false,\n\t\texceptionAccessor: false,\n\t\texceptionCount: false,\n\t\texceptionSum: false,\n\t\tfilter: false,\n\t\tvalueList: false,\n\t\tmedian: false,\n\t\thistogramValue: false,\n\t\tmin: false,\n\t\tmax: false,\n\t\thistogramThresholds: false,\n\t\tstd: false,\n\t\tsumOfSquares: false,\n\t\tvalues: false,\n\t\tnestKeys: false,\n\t\taliasKeys: false,\n\t\taliasPropKeys: false,\n\t\tgroupAll: false,\n\t\tdataList: false,\n\t\tcustom: false\n\t};\n};\n\nmodule.exports = reductio_parameters;\n","function postProcess(reductio) {\n    return function (group, p, f) {\n        group.post = function(){\n            var postprocess = function () {\n                return postprocess.all();\n            };\n            postprocess.all = function () {\n                return group.all();\n            };\n            var postprocessors = reductio.postprocessors;\n            Object.keys(postprocessors).forEach(function (name) {\n                postprocess[name] = function () {\n                    var _all = postprocess.all;\n                    var args = [].slice.call(arguments);\n                    postprocess.all = function () {\n                        return postprocessors[name](_all, f, p).apply(null, args);\n                    };\n                    return postprocess;\n                };\n            });\n            return postprocess;\n        };\n    };\n}\n\nmodule.exports = postProcess;\n","module.exports = function(reductio){\n    reductio.postprocessors = {};\n    reductio.registerPostProcessor = function(name, func){\n        reductio.postprocessors[name] = func;\n    };\n\n    reductio.registerPostProcessor('cap', require('./cap'));\n    reductio.registerPostProcessor('sortBy', require('./sortBy'));\n};\n","var reductio_build = require('./build.js');\nvar reductio_accessors = require('./accessors.js');\nvar reductio_parameters = require('./parameters.js');\nvar reductio_postprocess = require('./postprocess');\nvar crossfilter = require('crossfilter2');\n\nfunction reductio() {\n\tvar parameters = reductio_parameters();\n\n\tvar funcs = {};\n\n\tfunction my(group) {\n\t\t// Start fresh each time.\n\t\tfuncs = {\n\t\t\treduceAdd: function(p) { return p; },\n\t\t\treduceRemove: function(p) { return p; },\n\t\t\treduceInitial: function () { return {}; },\n\t\t};\n\n\t\treductio_build.build(parameters, funcs);\n\n\t\t// If we're doing groupAll\n\t\tif(parameters.groupAll) {\n\t\t\tif(group.top) {\n\t\t\t\tconsole.warn(\"'groupAll' is defined but attempting to run on a standard dimension.group(). Must run on dimension.groupAll().\");\n\t\t\t} else {\n\t\t\t\tvar bisect = crossfilter.bisect.by(function(d) { return d.key; }).left;\n\t\t\t\tvar i, j;\n\t\t\t\tvar keys;\n        var keysLength;\n        var k; // Key\n\t\t\t\tgroup.reduce(\n\t\t\t\t\tfunction(p, v, nf) {\n\t\t\t\t\t\tkeys = parameters.groupAll(v);\n            keysLength = keys.length;\n            for(j=0;j<keysLength;j++) {\n              k = keys[j];\n              i = bisect(p, k, 0, p.length);\n\t\t\t\t\t\t\tif(!p[i] || p[i].key !== k) {\n\t\t\t\t\t\t\t\t// If the group doesn't yet exist, create it first.\n\t\t\t\t\t\t\t\tp.splice(i, 0, { key: k, value: funcs.reduceInitial() });\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// Then pass the record and the group value to the reducers\n\t\t\t\t\t\t\tfuncs.reduceAdd(p[i].value, v, nf);\n            }\n\t\t\t\t\t\treturn p;\n\t\t\t\t\t},\n\t\t\t\t\tfunction(p, v, nf) {\n\t\t\t\t\t\tkeys = parameters.groupAll(v);\n            keysLength = keys.length;\n            for(j=0;j<keysLength;j++) {\n              i = bisect(p, keys[j], 0, p.length);\n\t\t\t\t\t\t\t// The group should exist or we're in trouble!\n\t\t\t\t\t\t\t// Then pass the record and the group value to the reducers\n\t\t\t\t\t\t\tfuncs.reduceRemove(p[i].value, v, nf);\n            }\n\t\t\t\t\t\treturn p;\n\t\t\t\t\t},\n\t\t\t\t\tfunction() {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t\tif(!group.all) {\n\t\t\t\t\t// Add an 'all' method for compatibility with standard Crossfilter groups.\n\t\t\t\t\tgroup.all = function() { return this.value(); };\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tgroup.reduce(funcs.reduceAdd, funcs.reduceRemove, funcs.reduceInitial);\n\t\t}\n\n\t\treductio_postprocess(group, parameters, funcs);\n\n\t\treturn group;\n\t}\n\n\treductio_accessors.build(my, parameters);\n\n\treturn my;\n}\n\nrequire('./postprocessors')(reductio);\nreductio_postprocess = reductio_postprocess(reductio);\n\nmodule.exports = reductio;\n","var pluck_n = function (n) {\n    if (typeof n === 'function') {\n        return n;\n    }\n    if (~n.indexOf('.')) {\n        var split = n.split('.');\n        return function (d) {\n            return split.reduce(function (p, v) {\n                return p[v];\n            }, d);\n        };\n    }\n    return function (d) {\n        return d[n];\n    };\n};\n\nfunction ascending(a, b) {\n    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n\nvar comparer = function (accessor, ordering) {\n    return function (a, b) {\n        return ordering(accessor(a), accessor(b));\n    };\n};\n\nvar type = {}.toString;\n\nmodule.exports = function (prior) {\n    return function (value, order) {\n        if (arguments.length === 1) {\n            order = ascending;\n        }\n        return prior().sort(comparer(pluck_n(value), order));\n    };\n};\n","var reductio_std = {\n\tadd: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tif(path(p).count > 0) {\n\t\t\t\tpath(p).std = 0.0;\n\t\t\t\tvar n = path(p).sumOfSq - path(p).sum*path(p).sum/path(p).count;\n\t\t\t\tif (n>0.0) path(p).std = Math.sqrt(n/(path(p).count-1));\n\t\t\t} else {\n\t\t\t\tpath(p).std = 0.0;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tif(path(p).count > 0) {\n\t\t\t\tpath(p).std = 0.0;\n\t\t\t\tvar n = path(p).sumOfSq - path(p).sum*path(p).sum/path(p).count;\n\t\t\t\tif (n>0.0) path(p).std = Math.sqrt(n/(path(p).count-1));\n\t\t\t} else {\n\t\t\t\tpath(p).std = 0;\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).std = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_std;","var reductio_sum_of_sq = {\n\tadd: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).sumOfSq = path(p).sumOfSq + a(v)*a(v);\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).sumOfSq = path(p).sumOfSq - a(v)*a(v);\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).sumOfSq = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_sum_of_sq;","var reductio_sum = {\n\tadd: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).sum = path(p).sum + a(v);\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\tpath(p).sum = path(p).sum - a(v);\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).sum = 0;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_sum;","var crossfilter = require('crossfilter2');\n\nvar reductio_value_count = {\n\tadd: function (a, prior, path) {\n\t\tvar i, curr;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Not sure if this is more efficient than sorting.\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\tcurr = path(p).values[i];\n\t\t\tif(curr && curr[0] === a(v)) {\n\t\t\t\t// Value already exists in the array - increment it\n\t\t\t\tcurr[1]++;\n\t\t\t} else {\n\t\t\t\t// Value doesn't exist - add it in form [value, 1]\n\t\t\t\tpath(p).values.splice(i, 0, [a(v), 1]);\n\t\t\t}\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\tvar i;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\ti = path(p).bisect(path(p).values, a(v), 0, path(p).values.length);\n\t\t\t// Value already exists or something has gone terribly wrong.\n\t\t\tpath(p).values[i][1]--;\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\t// Array[Array[value, count]]\n\t\t\tpath(p).values = [];\n\t\t\tpath(p).bisect = crossfilter.bisect.by(function(d) { return d[0]; }).left;\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_value_count;","var crossfilter = require('crossfilter2');\n\nvar reductio_value_list = {\n\tadd: function (a, prior, path) {\n\t\tvar i;\n\t\tvar bisect = crossfilter.bisect.by(function(d) { return d; }).left;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\t// Not sure if this is more efficient than sorting.\n\t\t\ti = bisect(path(p).valueList, a(v), 0, path(p).valueList.length);\n\t\t\tpath(p).valueList.splice(i, 0, a(v));\n\t\t\treturn p;\n\t\t};\n\t},\n\tremove: function (a, prior, path) {\n\t\tvar i;\n\t\tvar bisect = crossfilter.bisect.by(function(d) { return d; }).left;\n\t\treturn function (p, v, nf) {\n\t\t\tif(prior) prior(p, v, nf);\n\t\t\ti = bisect(path(p).valueList, a(v), 0, path(p).valueList.length);\n\t\t\t// Value already exists or something has gone terribly wrong.\n\t\t\tpath(p).valueList.splice(i, 1);\n\t\t\treturn p;\n\t\t};\n\t},\n\tinitial: function (prior, path) {\n\t\treturn function (p) {\n\t\t\tp = prior(p);\n\t\t\tpath(p).valueList = [];\n\t\t\treturn p;\n\t\t};\n\t}\n};\n\nmodule.exports = reductio_value_list;","'use strict'\n\nvar _ = require('./lodash')\n\nvar aggregators = {\n  // Collections\n  $sum: $sum,\n  $avg: $avg,\n  $max: $max,\n  $min: $min,\n\n  // Pickers\n  $count: $count,\n  $first: $first,\n  $last: $last,\n  $get: $get,\n  $nth: $get, // nth is same as using a get\n  $nthLast: $nthLast,\n  $nthPct: $nthPct,\n  $map: $map,\n}\n\nmodule.exports = {\n  makeValueAccessor: makeValueAccessor,\n  aggregators: aggregators,\n  extractKeyValOrArray: extractKeyValOrArray,\n  parseAggregatorParams: parseAggregatorParams,\n}\n// This is used to build aggregation stacks for sub-reductio\n// aggregations, or plucking values for use in filters from the data\nfunction makeValueAccessor(obj) {\n  if (typeof obj === 'string') {\n    if (isStringSyntax(obj)) {\n      obj = convertAggregatorString(obj)\n    } else {\n      // Must be a column key. Return an identity accessor\n      return obj\n    }\n  }\n  // Must be a column index. Return an identity accessor\n  if (typeof obj === 'number') {\n    return obj\n  }\n  // If it's an object, we need to build a custom value accessor function\n  if (_.isObject(obj)) {\n    return make()\n  }\n\n  function make() {\n    var stack = makeSubAggregationFunction(obj)\n    return function topStack(d) {\n      return stack(d)\n    }\n  }\n}\n\n// A recursive function that walks the aggregation stack and returns\n// a function. The returned function, when called, will recursively invoke\n// with the properties from the previous stack in reverse order\nfunction makeSubAggregationFunction(obj) {\n  // If its an object, either unwrap all of the properties as an\n  // array of keyValues, or unwrap the first keyValue set as an object\n  obj = _.isObject(obj) ? extractKeyValOrArray(obj) : obj\n\n  // Detect strings\n  if (_.isString(obj)) {\n    // If begins with a $, then we need to convert it over to a regular query object and analyze it again\n    if (isStringSyntax(obj)) {\n      return makeSubAggregationFunction(convertAggregatorString(obj))\n    }\n    // If normal string, then just return a an itentity accessor\n    return function identity(d) {\n      return d[obj]\n    }\n  }\n\n  // If an array, recurse into each item and return as a map\n  if (_.isArray(obj)) {\n    var subStack = _.map(obj, makeSubAggregationFunction)\n    return function getSubStack(d) {\n      return subStack.map(function(s) {\n        return s(d)\n      })\n    }\n  }\n\n  // If object, find the aggregation, and recurse into the value\n  if (obj.key) {\n    if (aggregators[obj.key]) {\n      var subAggregationFunction = makeSubAggregationFunction(obj.value)\n      return function getAggregation(d) {\n        return aggregators[obj.key](subAggregationFunction(d))\n      }\n    }\n    console.error('Could not find aggregration method', obj)\n  }\n\n  return []\n}\n\nfunction extractKeyValOrArray(obj) {\n  var keyVal\n  var values = []\n  for (var key in obj) {\n    if ({}.hasOwnProperty.call(obj, key)) {\n      keyVal = {\n        key: key,\n        value: obj[key],\n      }\n      var subObj = {}\n      subObj[key] = obj[key]\n      values.push(subObj)\n    }\n  }\n  return values.length > 1 ? values : keyVal\n}\n\nfunction isStringSyntax(str) {\n  return ['$', '('].indexOf(str.charAt(0)) > -1\n}\n\nfunction parseAggregatorParams(keyString) {\n  var params = []\n  var p1 = keyString.indexOf('(')\n  var p2 = keyString.indexOf(')')\n  var key = p1 > -1 ? keyString.substring(0, p1) : keyString\n  if (!aggregators[key]) {\n    return false\n  }\n  if (p1 > -1 && p2 > -1 && p2 > p1) {\n    params = keyString.substring(p1 + 1, p2).split(',')\n  }\n\n  return {\n    aggregator: aggregators[key],\n    params: params,\n  }\n}\n\nfunction convertAggregatorString(keyString) {\n  // var obj = {} // obj is defined but not used\n\n  // 1. unwrap top parentheses\n  // 2. detect arrays\n\n  // parentheses\n  var outerParens = /\\((.+)\\)/g\n  // var innerParens = /\\(([^\\(\\)]+)\\)/g  // innerParens is defined but not used\n  // comma not in ()\n  var hasComma = /(?:\\([^\\(\\)]*\\))|(,)/g\n\n  return JSON.parse('{' + unwrapParensAndCommas(keyString) + '}')\n\n  function unwrapParensAndCommas(str) {\n    str = str.replace(' ', '')\n    return (\n      '\"' +\n      str.replace(outerParens, function(p, pr) {\n        if (hasComma.test(pr)) {\n          if (pr.charAt(0) === '$') {\n            return (\n              '\":{\"' +\n              pr.replace(hasComma, function(p2 /* , pr2 */) {\n                if (p2 === ',') {\n                  return ',\"'\n                }\n                return unwrapParensAndCommas(p2).trim()\n              }) +\n              '}'\n            )\n          }\n          return (\n            ':[\"' +\n            pr.replace(\n              hasComma,\n              function(/* p2 , pr2 */) {\n                return '\",\"'\n              }\n            ) +\n            '\"]'\n          )\n        }\n      })\n    )\n  }\n}\n\n// Collection Aggregators\n\nfunction $sum(children) {\n  return children.reduce(function(a, b) {\n    return a + b\n  }, 0)\n}\n\nfunction $avg(children) {\n  return (\n    children.reduce(function(a, b) {\n      return a + b\n    }, 0) / children.length\n  )\n}\n\nfunction $max(children) {\n  return Math.max.apply(null, children)\n}\n\nfunction $min(children) {\n  return Math.min.apply(null, children)\n}\n\nfunction $count(children) {\n  return children.length\n}\n\n/* function $med(children) { // $med is defined but not used\n  children.sort(function(a, b) {\n    return a - b\n  })\n  var half = Math.floor(children.length / 2)\n  if (children.length % 2)\n    return children[half]\n  else\n    return (children[half - 1] + children[half]) / 2.0\n} */\n\nfunction $first(children) {\n  return children[0]\n}\n\nfunction $last(children) {\n  return children[children.length - 1]\n}\n\nfunction $get(children, n) {\n  return children[n]\n}\n\nfunction $nthLast(children, n) {\n  return children[children.length - n]\n}\n\nfunction $nthPct(children, n) {\n  return children[Math.round(children.length * (n / 100))]\n}\n\nfunction $map(children, n) {\n  return children.map(function(d) {\n    return d[n]\n  })\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nmodule.exports = function(service) {\n  return function clear(def) {\n    // Clear a single or multiple column definitions\n    if (def) {\n      def = _.isArray(def) ? def : [def]\n    }\n\n    if (!def) {\n      // Clear all of the column defenitions\n      return Promise.all(\n        _.map(service.columns, disposeColumn)\n      ).then(function() {\n        service.columns = []\n        return service\n      })\n    }\n\n    return Promise.all(\n      _.map(def, function(d) {\n        if (_.isObject(d)) {\n          d = d.key\n        }\n        // Clear the column\n        var column = _.remove(service.columns, function(c) {\n          if (_.isArray(d)) {\n            return !_.xor(c.key, d).length\n          }\n          if (c.key === d) {\n            if (c.dynamicReference) {\n              return false\n            }\n            return true\n          }\n        })[0]\n\n        if (!column) {\n          // console.info('Attempted to clear a column that is required for another query!', c)\n          return\n        }\n\n        disposeColumn(column)\n      })\n    ).then(function() {\n      return service\n    })\n\n    function disposeColumn(column) {\n      var disposalActions = []\n      // Dispose the dimension\n      if (column.removeListeners) {\n        disposalActions = _.map(column.removeListeners, function(listener) {\n          return Promise.resolve(listener())\n        })\n      }\n      var filterKey = column.key\n      if (column.complex === 'array') {\n        filterKey = JSON.stringify(column.key)\n      }\n      if (column.complex === 'function') {\n        filterKey = column.key.toString()\n      }\n      delete service.filters[filterKey]\n      if (column.dimension) {\n        disposalActions.push(Promise.resolve(column.dimension.dispose()))\n      }\n      return Promise.all(disposalActions)\n    }\n  }\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nmodule.exports = function (service) {\n  var dimension = require('./dimension')(service)\n\n  var columnFunc = column\n  columnFunc.find = findColumn\n\n  return columnFunc\n\n  function column(def) {\n    // Support groupAll dimension\n    if (_.isUndefined(def)) {\n      def = true\n    }\n\n    // Always deal in bulk.  Like Costco!\n    if (!_.isArray(def)) {\n      def = [def]\n    }\n\n    // Mapp all column creation, wait for all to settle, then return the instance\n    return Promise.all(_.map(def, makeColumn))\n      .then(function () {\n        return service\n      })\n  }\n\n  function findColumn(d) {\n    return _.find(service.columns, function (c) {\n      if (_.isArray(d)) {\n        return !_.xor(c.key, d).length\n      }\n      return c.key === d\n    })\n  }\n\n  function getType(d) {\n    if (_.isNumber(d)) {\n      return 'number'\n    }\n    if (_.isBoolean(d)) {\n      return 'bool'\n    }\n    if (_.isArray(d)) {\n      return 'array'\n    }\n    if (_.isObject(d)) {\n      return 'object'\n    }\n    return 'string'\n  }\n\n  function makeColumn(d) {\n    var column = _.isObject(d) ? d : {\n      key: d,\n    }\n\n    var existing = findColumn(column.key)\n\n    if (existing) {\n      existing.temporary = false\n      if (existing.dynamicReference) {\n        existing.dynamicReference = false\n      }\n      return existing.promise\n        .then(function () {\n          return service\n        })\n    }\n\n    // for storing info about queries and post aggregations\n    column.queries = []\n    service.columns.push(column)\n\n    column.promise = new Promise(function (resolve, reject) {\n      try {\n        resolve(service.cf.all())\n      } catch (err) {\n        reject(err)\n      }\n    })\n      .then(function (all) {\n        var sample\n\n        // Complex column Keys\n        if (_.isFunction(column.key)) {\n          column.complex = 'function'\n          sample = column.key(all[0])\n        } else if (_.isString(column.key) && (column.key.indexOf('.') > -1 || column.key.indexOf('[') > -1)) {\n          column.complex = 'string'\n          sample = _.get(all[0], column.key)\n        } else if (_.isArray(column.key)) {\n          column.complex = 'array'\n          sample = _.values(_.pick(all[0], column.key))\n          if (sample.length !== column.key.length) {\n            throw new Error('Column key does not exist in data!', column.key)\n          }\n        } else {\n          sample = all[0][column.key]\n        }\n\n        // Index Column\n        if (!column.complex && column.key !== true && typeof sample === 'undefined') {\n          throw new Error('Column key does not exist in data!', column.key)\n        }\n\n        // If the column exists, let's at least make sure it's marked\n        // as permanent. There is a slight chance it exists because\n        // of a filter, and the user decides to make it permanent\n\n        if (column.key === true) {\n          column.type = 'all'\n        } else if (column.complex) {\n          column.type = 'complex'\n        } else if (column.array) {\n          column.type = 'array'\n        } else {\n          column.type = getType(sample)\n        }\n\n        return dimension.make(column.key, column.type, column.complex)\n      })\n      .then(function (dim) {\n        column.dimension = dim\n        column.filterCount = 0\n        var stopListeningForData = service.onDataChange(buildColumnKeys)\n        column.removeListeners = [stopListeningForData]\n\n        return buildColumnKeys()\n\n        // Build the columnKeys\n        function buildColumnKeys(changes) {\n          if (column.key === true) {\n            return Promise.resolve()\n          }\n\n          var accessor = dimension.makeAccessor(column.key, column.complex)\n          column.values = column.values || []\n\n          return new Promise(function (resolve, reject) {\n            try {\n              if (changes && changes.added) {\n                resolve(changes.added)\n              } else {\n                resolve(column.dimension.bottom(Infinity))\n              }\n            } catch (err) {\n              reject(err)\n            }\n          })\n            .then(function (rows) {\n              var newValues\n              if (column.complex === 'string' || column.complex === 'function') {\n                newValues = _.map(rows, accessor)\n                // console.log(rows, accessor.toString(), newValues)\n              } else if (column.type === 'array') {\n                newValues = _.flatten(_.map(rows, accessor))\n              } else {\n                newValues = _.map(rows, accessor)\n              }\n              column.values = _.uniq(column.values.concat(newValues))\n            })\n        }\n      })\n\n    return column.promise\n      .then(function () {\n        return service\n      })\n  }\n}\n","'use strict'\n\nvar crossfilter = require('crossfilter2')\n\nvar _ = require('./lodash')\n\nmodule.exports = function (service) {\n  return {\n    build: build,\n    generateColumns: generateColumns,\n    add: add,\n    remove: remove,\n  }\n\n  function build(c) {\n    if (_.isArray(c)) {\n      // This allows support for crossfilter async\n      return Promise.resolve(crossfilter(c))\n    }\n    if (!c || typeof c.dimension !== 'function') {\n      return Promise.reject(new Error('No Crossfilter data or instance found!'))\n    }\n    return Promise.resolve(c)\n  }\n\n  function generateColumns(data) {\n    if (!service.options.generatedColumns) {\n      return data\n    }\n    return _.map(data, function (d/* , i */) {\n      _.forEach(service.options.generatedColumns, function (val, key) {\n        d[key] = val(d)\n      })\n      return d\n    })\n  }\n\n  function add(data) {\n    data = generateColumns(data)\n    return new Promise(function (resolve, reject) {\n      try {\n        resolve(service.cf.add(data))\n      } catch (err) {\n        reject(err)\n      }\n    })\n      .then(function () {\n        return _.map(service.dataListeners, function (listener) {\n          return function () {\n            return listener({\n              added: data,\n            })\n          }\n        }).reduce(function(promise, data) {\n          return promise.then(data)\n        }, Promise.resolve(true))\n      })\n\n    .then(function() {\n      return Promise.all(_.map(service.filterListeners, function (listener) {\n         return listener()\n      }))      \n    })\n\n      .then(function () {\n        return service\n      })\n  }\n\n  function remove(predicate) {\n    return new Promise(function (resolve, reject) {\n      try {\n        resolve(service.cf.remove(predicate))\n      } catch (err) {\n        reject(err)\n      }\n    })\n    \n    .then(function() {\n      return Promise.all(_.map(service.filterListeners, function (listener) {\n         return listener()\n      }))      \n    })\n    \n    .then(function () {\n      return service\n    })\n  }\n}\n\n\n","'use strict'\n\n// var _ = require('./lodash') // _ is defined but never used\n\nmodule.exports = function (service) {\n  return function destroy() {\n    return service.clear()\n      .then(function () {\n        service.cf.dataListeners = []\n        service.cf.filterListeners = []\n        return Promise.resolve(service.cf.remove())\n      })\n      .then(function () {\n        return service\n      })\n  }\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nmodule.exports = function (service) {\n  return {\n    make: make,\n    makeAccessor: makeAccessor,\n  }\n\n  function make(key, type, complex) {\n    var accessor = makeAccessor(key, complex)\n    // Promise.resolve will handle promises or non promises, so\n    // this crossfilter async is supported if present\n    return Promise.resolve(service.cf.dimension(accessor, type === 'array'))\n  }\n\n  function makeAccessor(key, complex) {\n    var accessorFunction\n\n    if (complex === 'string') {\n      accessorFunction = function (d) {\n        return _.get(d, key)\n      }\n    } else if (complex === 'function') {\n      accessorFunction = key\n    } else if (complex === 'array') {\n      var arrayString = _.map(key, function (k) {\n        return 'd[\\'' + k + '\\']'\n      })\n      accessorFunction = new Function('d', String('return ' + JSON.stringify(arrayString).replace(/\"/g, '')))  // eslint-disable-line  no-new-func\n    } else {\n      accessorFunction =\n        // Index Dimension\n        key === true ? function accessor(d, i) {\n          return i\n        } :\n          // Value Accessor Dimension\n          function (d) {\n            return d[key]\n          }\n    }\n    return accessorFunction\n  }\n}\n","'use strict'\n\n// var moment = require('moment')\n\nmodule.exports = {\n  // Getters\n  $field: $field,\n  // Booleans\n  $and: $and,\n  $or: $or,\n  $not: $not,\n\n  // Expressions\n  $eq: $eq,\n  $gt: $gt,\n  $gte: $gte,\n  $lt: $lt,\n  $lte: $lte,\n  $ne: $ne,\n  $type: $type,\n\n  // Array Expressions\n  $in: $in,\n  $nin: $nin,\n  $contains: $contains,\n  $excludes: $excludes,\n  $size: $size,\n}\n\n// Getters\nfunction $field(d, child) {\n  return d[child]\n}\n\n// Operators\n\nfunction $and(d, child) {\n  child = child(d)\n  for (var i = 0; i < child.length; i++) {\n    if (!child[i]) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction $or(d, child) {\n  child = child(d)\n  for (var i = 0; i < child.length; i++) {\n    if (child[i]) {\n      return true\n    }\n  }\n  return false\n}\n\nfunction $not(d, child) {\n  child = child(d)\n  for (var i = 0; i < child.length; i++) {\n    if (child[i]) {\n      return false\n    }\n  }\n  return true\n}\n\n// Expressions\n\nfunction $eq(d, child) {\n  return d === child()\n}\n\nfunction $gt(d, child) {\n  return d > child()\n}\n\nfunction $gte(d, child) {\n  return d >= child()\n}\n\nfunction $lt(d, child) {\n  return d < child()\n}\n\nfunction $lte(d, child) {\n  return d <= child()\n}\n\nfunction $ne(d, child) {\n  return d !== child()\n}\n\nfunction $type(d, child) {\n  return typeof d === child()\n}\n\n// Array Expressions\n\nfunction $in(d, child) {\n  return d.indexOf(child()) > -1\n}\n\nfunction $nin(d, child) {\n  return d.indexOf(child()) === -1\n}\n\nfunction $contains(d, child) {\n  return child().indexOf(d) > -1\n}\n\nfunction $excludes(d, child) {\n  return child().indexOf(d) === -1\n}\n\nfunction $size(d, child) {\n  return d.length === child()\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nvar expressions = require('./expressions')\nvar aggregation = require('./aggregation')\n\nmodule.exports = function (service) {\n  return {\n    filter: filter,\n    filterAll: filterAll,\n    applyFilters: applyFilters,\n    makeFunction: makeFunction,\n    scanForDynamicFilters: scanForDynamicFilters,\n  }\n\n  function filter(column, fil, isRange, replace) {\n    return getColumn(column)\n      .then(function (column) {\n      // Clone a copy of the new filters\n        var newFilters = _.assign({}, service.filters)\n        // Here we use the registered column key despite the filter key passed, just in case the filter key's ordering is ordered differently :)\n        var filterKey = column.key\n        if (column.complex === 'array') {\n          filterKey = JSON.stringify(column.key)\n        }\n        if (column.complex === 'function') {\n          filterKey = column.key.toString()\n        }\n        // Build the filter object\n        newFilters[filterKey] = buildFilterObject(fil, isRange, replace)\n\n        return applyFilters(newFilters)\n      })\n  }\n\n  function getColumn(column) {\n    var exists = service.column.find(column)\n    // If the filters dimension doesn't exist yet, try and create it\n    return new Promise(function (resolve, reject) {\n      try {\n        if (!exists) {\n          return resolve(service.column({\n            key: column,\n            temporary: true,\n          })\n            .then(function () {\n              // It was able to be created, so retrieve and return it\n              return service.column.find(column)\n            })\n          )\n        } else {\n          // It exists, so just return what we found\n          resolve(exists)\n        }\n      } catch (err) {\n        reject(err)\n      }\n    })\n  }\n\n  function filterAll(fils) {\n    // If empty, remove all filters\n    if (!fils) {\n      service.columns.forEach(function (col) {\n        col.dimension.filterAll()\n      })\n      return applyFilters({})\n    }\n\n    // Clone a copy for the new filters\n    var newFilters = _.assign({}, service.filters)\n\n    var ds = _.map(fils, function (fil) {\n      return getColumn(fil.column)\n        .then(function (column) {\n          // Here we use the registered column key despite the filter key passed, just in case the filter key's ordering is ordered differently :)\n          var filterKey = column.complex ? JSON.stringify(column.key) : column.key\n          // Build the filter object\n          newFilters[filterKey] = buildFilterObject(fil.value, fil.isRange, fil.replace)\n        })\n    })\n\n    return Promise.all(ds)\n      .then(function () {\n        return applyFilters(newFilters)\n      })\n  }\n\n  function buildFilterObject(fil, isRange, replace) {\n    if (_.isUndefined(fil)) {\n      return false\n    }\n    if (_.isFunction(fil)) {\n      return {\n        value: fil,\n        function: fil,\n        replace: true,\n        type: 'function',\n      }\n    }\n    if (_.isObject(fil)) {\n      return {\n        value: fil,\n        function: makeFunction(fil),\n        replace: true,\n        type: 'function',\n      }\n    }\n    if (_.isArray(fil)) {\n      return {\n        value: fil,\n        replace: isRange || replace,\n        type: isRange ? 'range' : 'inclusive',\n      }\n    }\n    return {\n      value: fil,\n      replace: replace,\n      type: 'exact',\n    }\n  }\n\n  function applyFilters(newFilters) {\n    var ds = _.map(newFilters, function (fil, i) {\n      var existing = service.filters[i]\n      // Filters are the same, so no change is needed on this column\n      if (fil === existing) {\n        return Promise.resolve()\n      }\n      var column\n      // Retrieve complex columns by decoding the column key as json\n      if (i.charAt(0) === '[') {\n        column = service.column.find(JSON.parse(i))\n      } else {\n        // Retrieve the column normally\n        column = service.column.find(i)\n      }\n\n      // Toggling a filter value is a bit different from replacing them\n      if (fil && existing && !fil.replace) {\n        newFilters[i] = fil = toggleFilters(fil, existing)\n      }\n\n      // If no filter, remove everything from the dimension\n      if (!fil) {\n        return Promise.resolve(column.dimension.filterAll())\n      }\n      if (fil.type === 'exact') {\n        return Promise.resolve(column.dimension.filterExact(fil.value))\n      }\n      if (fil.type === 'range') {\n        return Promise.resolve(column.dimension.filterRange(fil.value))\n      }\n      if (fil.type === 'inclusive') {\n        return Promise.resolve(column.dimension.filterFunction(function (d) {\n          return fil.value.indexOf(d) > -1\n        }))\n      }\n      if (fil.type === 'function') {\n        return Promise.resolve(column.dimension.filterFunction(fil.function))\n      }\n      // By default if something craps up, just remove all filters\n      return Promise.resolve(column.dimension.filterAll())\n    })\n\n    return Promise.all(ds)\n      .then(function () {\n        // Save the new filters satate\n        service.filters = newFilters\n\n        // Pluck and remove falsey filters from the mix\n        var tryRemoval = []\n        _.forEach(service.filters, function (val, key) {\n          if (!val) {\n            tryRemoval.push({\n              key: key,\n              val: val,\n            })\n            delete service.filters[key]\n          }\n        })\n\n        // If any of those filters are the last dependency for the column, then remove the column\n        return Promise.all(_.map(tryRemoval, function (v) {\n          var column = service.column.find((v.key.charAt(0) === '[') ? JSON.parse(v.key) : v.key)\n          if (column.temporary && !column.dynamicReference) {\n            return service.clear(column.key)\n          }\n        }))\n      })\n      .then(function () {\n        // Call the filterListeners and wait for their return\n        return Promise.all(_.map(service.filterListeners, function (listener) {\n          return listener()\n        }))\n      })\n      .then(function () {\n        return service\n      })\n  }\n\n  function toggleFilters(fil, existing) {\n    // Exact from Inclusive\n    if (fil.type === 'exact' && existing.type === 'inclusive') {\n      fil.value = _.xor([fil.value], existing.value)\n    } else if (fil.type === 'inclusive' && existing.type === 'exact') { // Inclusive from Exact\n      fil.value = _.xor(fil.value, [existing.value])\n    } else if (fil.type === 'inclusive' && existing.type === 'inclusive') { // Inclusive / Inclusive Merge\n      fil.value = _.xor(fil.value, existing.value)\n    } else if (fil.type === 'exact' && existing.type === 'exact') { // Exact / Exact\n      // If the values are the same, remove the filter entirely\n      if (fil.value === existing.value) {\n        return false\n      }\n      // They they are different, make an array\n      fil.value = [fil.value, existing.value]\n    }\n\n    // Set the new type based on the merged values\n    if (!fil.value.length) {\n      fil = false\n    } else if (fil.value.length === 1) {\n      fil.type = 'exact'\n      fil.value = fil.value[0]\n    } else {\n      fil.type = 'inclusive'\n    }\n\n    return fil\n  }\n\n  function scanForDynamicFilters(query) {\n    // Here we check to see if there are any relative references to the raw data\n    // being used in the filter. If so, we need to build those dimensions and keep\n    // them updated so the filters can be rebuilt if needed\n    // The supported keys right now are: $column, $data\n    var columns = []\n    walk(query.filter)\n    return columns\n\n    function walk(obj) {\n      _.forEach(obj, function (val, key) {\n        // find the data references, if any\n        var ref = findDataReferences(val, key)\n        if (ref) {\n          columns.push(ref)\n        }\n        // if it's a string\n        if (_.isString(val)) {\n          ref = findDataReferences(null, val)\n          if (ref) {\n            columns.push(ref)\n          }\n        }\n        // If it's another object, keep looking\n        if (_.isObject(val)) {\n          walk(val)\n        }\n      })\n    }\n  }\n\n  function findDataReferences(val, key) {\n    // look for the $data string as a value\n    if (key === '$data') {\n      return true\n    }\n\n    // look for the $column key and it's value as a string\n    if (key && key === '$column') {\n      if (_.isString(val)) {\n        return val\n      }\n      console.warn('The value for filter \"$column\" must be a valid column key', val)\n      return false\n    }\n  }\n\n  function makeFunction(obj, isAggregation) {\n    var subGetters\n\n    // Detect raw $data reference\n    if (_.isString(obj)) {\n      var dataRef = findDataReferences(null, obj)\n      if (dataRef) {\n        var data = service.cf.all()\n        return function () {\n          return data\n        }\n      }\n    }\n\n    if (_.isString(obj) || _.isNumber(obj) || _.isBoolean(obj)) {\n      return function (d) {\n        if (typeof d === 'undefined') {\n          return obj\n        }\n        return expressions.$eq(d, function () {\n          return obj\n        })\n      }\n    }\n\n    // If an array, recurse into each item and return as a map\n    if (_.isArray(obj)) {\n      subGetters = _.map(obj, function (o) {\n        return makeFunction(o, isAggregation)\n      })\n      return function (d) {\n        return subGetters.map(function (s) {\n          return s(d)\n        })\n      }\n    }\n\n    // If object, return a recursion function that itself, returns the results of all of the object keys\n    if (_.isObject(obj)) {\n      subGetters = _.map(obj, function (val, key) {\n        // Get the child\n        var getSub = makeFunction(val, isAggregation)\n\n        // Detect raw $column references\n        var dataRef = findDataReferences(val, key)\n        if (dataRef) {\n          var column = service.column.find(dataRef)\n          var data = column.values\n          return function () {\n            return data\n          }\n        }\n\n        // If expression, pass the parentValue and the subGetter\n        if (expressions[key]) {\n          return function (d) {\n            return expressions[key](d, getSub)\n          }\n        }\n\n        var aggregatorObj = aggregation.parseAggregatorParams(key)\n        if (aggregatorObj) {\n          // Make sure that any further operations are for aggregations\n          // and not filters\n          isAggregation = true\n          // here we pass true to makeFunction which denotes that\n          // an aggregatino chain has started and to stop using $AND\n          getSub = makeFunction(val, isAggregation)\n          // If it's an aggregation object, be sure to pass in the children, and then any additional params passed into the aggregation string\n          return function () {\n            return aggregatorObj.aggregator.apply(null, [getSub()].concat(aggregatorObj.params))\n          }\n        }\n\n        // It must be a string then. Pluck that string key from parent, and pass it as the new value to the subGetter\n        return function (d) {\n          d = d[key]\n          return getSub(d, getSub)\n        }\n      })\n\n      // All object expressions are basically AND's\n      // Return AND with a map of the subGetters\n      if (isAggregation) {\n        if (subGetters.length === 1) {\n          return function (d) {\n            return subGetters[0](d)\n          }\n        }\n        return function (d) {\n          return _.map(subGetters, function (getSub) {\n            return getSub(d)\n          })\n        }\n      }\n      return function (d) {\n        return expressions.$and(d, function (d) {\n          return _.map(subGetters, function (getSub) {\n            return getSub(d)\n          })\n        })\n      }\n    }\n\n    console.log('no expression found for ', obj)\n    return false\n  }\n}\n","/* eslint no-prototype-builtins: 0 */\n'use strict'\n\nmodule.exports = {\n  assign: assign,\n  find: find,\n  remove: remove,\n  isArray: isArray,\n  isObject: isObject,\n  isBoolean: isBoolean,\n  isString: isString,\n  isNumber: isNumber,\n  isFunction: isFunction,\n  get: get,\n  set: set,\n  map: map,\n  keys: keys,\n  sortBy: sortBy,\n  forEach: forEach,\n  isUndefined: isUndefined,\n  pick: pick,\n  xor: xor,\n  clone: clone,\n  isEqual: isEqual,\n  replaceArray: replaceArray,\n  uniq: uniq,\n  flatten: flatten,\n  sort: sort,\n  values: values,\n  recurseObject: recurseObject,\n}\n\nfunction assign(out) {\n  out = out || {}\n  for (var i = 1; i < arguments.length; i++) {\n    if (!arguments[i]) {\n      continue\n    }\n    for (var key in arguments[i]) {\n      if (arguments[i].hasOwnProperty(key)) {\n        out[key] = arguments[i][key]\n      }\n    }\n  }\n  return out\n}\n\nfunction find(a, b) {\n  return a.find(b)\n}\n\nfunction remove(a, b) {\n  return a.filter(function (o, i) {\n    var r = b(o)\n    if (r) {\n      a.splice(i, 1)\n      return true\n    }\n    return false\n  })\n}\n\nfunction isArray(a) {\n  return Array.isArray(a)\n}\n\nfunction isObject(d) {\n  return typeof d === 'object' && !isArray(d)\n}\n\nfunction isBoolean(d) {\n  return typeof d === 'boolean'\n}\n\nfunction isString(d) {\n  return typeof d === 'string'\n}\n\nfunction isNumber(d) {\n  return typeof d === 'number'\n}\n\nfunction isFunction(a) {\n  return typeof a === 'function'\n}\n\nfunction get(a, b) {\n  if (isArray(b)) {\n    b = b.join('.')\n  }\n  return b\n    .replace('[', '.').replace(']', '')\n    .split('.')\n    .reduce(\n      function (obj, property) {\n        return obj[property]\n      }, a\n    )\n}\n\nfunction set(obj, prop, value) {\n  if (typeof prop === 'string') {\n    prop = prop\n      .replace('[', '.').replace(']', '')\n      .split('.')\n  }\n  if (prop.length > 1) {\n    var e = prop.shift()\n    assign(obj[e] =\n      Object.prototype.toString.call(obj[e]) === '[object Object]' ? obj[e] : {},\n    prop,\n    value)\n  } else {\n    obj[prop[0]] = value\n  }\n}\n\nfunction map(a, b) {\n  var m\n  var key\n  if (isFunction(b)) {\n    if (isObject(a)) {\n      m = []\n      for (key in a) {\n        if (a.hasOwnProperty(key)) {\n          m.push(b(a[key], key, a))\n        }\n      }\n      return m\n    }\n    return a.map(b)\n  }\n  if (isObject(a)) {\n    m = []\n    for (key in a) {\n      if (a.hasOwnProperty(key)) {\n        m.push(a[key])\n      }\n    }\n    return m\n  }\n  return a.map(function (aa) {\n    return aa[b]\n  })\n}\n\nfunction keys(obj) {\n  return Object.keys(obj)\n}\n\nfunction sortBy(a, b) {\n  if (isFunction(b)) {\n    return a.sort(function (aa, bb) {\n      if (b(aa) > b(bb)) {\n        return 1\n      }\n      if (b(aa) < b(bb)) {\n        return -1\n      }\n      // a must be equal to b\n      return 0\n    })\n  }\n}\n\nfunction forEach(a, b) {\n  if (isObject(a)) {\n    for (var key in a) {\n      if (a.hasOwnProperty(key)) {\n        b(a[key], key, a)\n      }\n    }\n    return\n  }\n  if (isArray(a)) {\n    return a.forEach(b)\n  }\n}\n\nfunction isUndefined(a) {\n  return typeof a === 'undefined'\n}\n\nfunction pick(a, b) {\n  var c = {}\n  forEach(b, function (bb) {\n    if (typeof a[bb] !== 'undefined') {\n      c[bb] = a[bb]\n    }\n  })\n  return c\n}\n\nfunction xor(a, b) {\n  var unique = []\n  forEach(a, function (aa) {\n    if (b.indexOf(aa) === -1) {\n      return unique.push(aa)\n    }\n  })\n  forEach(b, function (bb) {\n    if (a.indexOf(bb) === -1) {\n      return unique.push(bb)\n    }\n  })\n  return unique\n}\n\nfunction clone(a) {\n  return JSON.parse(JSON.stringify(a, function replacer(key, value) {\n    if (typeof value === 'function') {\n      return value.toString()\n    }\n    return value\n  }))\n}\n\nfunction isEqual(x, y) {\n  if ((typeof x === 'object' && x !== null) && (typeof y === 'object' && y !== null)) {\n    if (Object.keys(x).length !== Object.keys(y).length) {\n      return false\n    }\n\n    for (var prop in x) {\n      if (y.hasOwnProperty(prop)) {\n        if (!isEqual(x[prop], y[prop])) {\n          return false\n        }\n      }\n      return false\n    }\n\n    return true\n  } else if (x !== y) {\n    return false\n  }\n  return true\n}\n\nfunction replaceArray(a, b) {\n  var al = a.length\n  var bl = b.length\n  if (al > bl) {\n    a.splice(bl, al - bl)\n  } else if (al < bl) {\n    a.push.apply(a, new Array(bl - al))\n  }\n  forEach(a, function (val, key) {\n    a[key] = b[key]\n  })\n  return a\n}\n\nfunction uniq(a) {\n  var seen = new Set()\n  return a.filter(function (item) {\n    var allow = false\n    if (!seen.has(item)) {\n      seen.add(item)\n      allow = true\n    }\n    return allow\n  })\n}\n\nfunction flatten(aa) {\n  var flattened = []\n  for (var i = 0; i < aa.length; ++i) {\n    var current = aa[i]\n    for (var j = 0; j < current.length; ++j) {\n      flattened.push(current[j])\n    }\n  }\n  return flattened\n}\n\nfunction sort(arr) {\n  for (var i = 1; i < arr.length; i++) {\n    var tmp = arr[i]\n    var j = i\n    while (arr[j - 1] > tmp) {\n      arr[j] = arr[j - 1]\n      --j\n    }\n    arr[j] = tmp\n  }\n\n  return arr\n}\n\nfunction values(a) {\n  var values = []\n  for (var key in a) {\n    if (a.hasOwnProperty(key)) {\n      values.push(a[key])\n    }\n  }\n  return values\n}\n\nfunction recurseObject(obj, cb) {\n  _recurseObject(obj, [])\n  return obj\n  function _recurseObject(obj, path) {\n    for (var k in obj) { //  eslint-disable-line guard-for-in\n      var newPath = clone(path)\n      newPath.push(k)\n      if (typeof obj[k] === 'object' && obj[k] !== null) {\n        _recurseObject(obj[k], newPath)\n      } else {\n        if (!obj.hasOwnProperty(k)) {\n          continue\n        }\n        cb(obj[k], k, newPath)\n      }\n    }\n  }\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nvar aggregation = require('./aggregation')\n\nmodule.exports = function (/* service */) {\n  return {\n    post: post,\n    sortByKey: sortByKey,\n    limit: limit,\n    squash: squash,\n    change: change,\n    changeMap: changeMap,\n  }\n\n  function post(query, parent, cb) {\n    query.data = cloneIfLocked(parent)\n    return Promise.resolve(cb(query, parent))\n  }\n\n  function sortByKey(query, parent, desc) {\n    query.data = cloneIfLocked(parent)\n    query.data = _.sortBy(query.data, function (d) {\n      return d.key\n    })\n    if (desc) {\n      query.data.reverse()\n    }\n  }\n\n  // Limit results to n, or from start to end\n  function limit(query, parent, start, end) {\n    query.data = cloneIfLocked(parent)\n    if (_.isUndefined(end)) {\n      end = start || 0\n      start = 0\n    } else {\n      start = start || 0\n      end = end || query.data.length\n    }\n    query.data = query.data.splice(start, end - start)\n  }\n\n  // Squash results to n, or from start to end\n  function squash(query, parent, start, end, aggObj, label) {\n    query.data = cloneIfLocked(parent)\n    start = start || 0\n    end = end || query.data.length\n    var toSquash = query.data.splice(start, end - start)\n    var squashed = {\n      key: label || 'Other',\n      value: {},\n    }\n    _.recurseObject(aggObj, function (val, key, path) {\n      var items = []\n      _.forEach(toSquash, function (record) {\n        items.push(_.get(record.value, path))\n      })\n      _.set(squashed.value, path, aggregation.aggregators[val](items))\n    })\n    query.data.splice(start, 0, squashed)\n  }\n\n  function change(query, parent, start, end, aggObj) {\n    query.data = cloneIfLocked(parent)\n    start = start || 0\n    end = end || query.data.length\n    var obj = {\n      key: [query.data[start].key, query.data[end].key],\n      value: {},\n    }\n    _.recurseObject(aggObj, function (val, key, path) {\n      var changePath = _.clone(path)\n      changePath.pop()\n      changePath.push(key + 'Change')\n      _.set(obj.value, changePath, _.get(query.data[end].value, path) - _.get(query.data[start].value, path))\n    })\n    query.data = obj\n  }\n\n  function changeMap(query, parent, aggObj, defaultNull) {\n    defaultNull = _.isUndefined(defaultNull) ? 0 : defaultNull\n    query.data = cloneIfLocked(parent)\n    _.recurseObject(aggObj, function (val, key, path) {\n      var changePath = _.clone(path)\n      var fromStartPath = _.clone(path)\n      var fromEndPath = _.clone(path)\n\n      changePath.pop()\n      fromStartPath.pop()\n      fromEndPath.pop()\n\n      changePath.push(key + 'Change')\n      fromStartPath.push(key + 'ChangeFromStart')\n      fromEndPath.push(key + 'ChangeFromEnd')\n\n      var start = _.get(query.data[0].value, path, defaultNull)\n      var end = _.get(query.data[query.data.length - 1].value, path, defaultNull)\n\n      _.forEach(query.data, function (record, i) {\n        var previous = query.data[i - 1] || query.data[0]\n        _.set(query.data[i].value, changePath, _.get(record.value, path, defaultNull) - (previous ? _.get(previous.value, path, defaultNull) : defaultNull))\n        _.set(query.data[i].value, fromStartPath, _.get(record.value, path, defaultNull) - start)\n        _.set(query.data[i].value, fromEndPath, _.get(record.value, path, defaultNull) - end)\n      })\n    })\n  }\n}\n\nfunction cloneIfLocked(parent) {\n  return parent.locked ? _.clone(parent.data) : parent.data\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nmodule.exports = function (service) {\n  var reductiofy = require('./reductiofy')(service)\n  var filters = require('./filters')(service)\n  var postAggregation = require('./postAggregation')(service)\n\n  var postAggregationMethods = _.keys(postAggregation)\n\n  return function doQuery(queryObj) {\n    var queryHash = JSON.stringify(queryObj)\n\n    // Attempt to reuse an exact copy of this query that is present elsewhere\n    for (var i = 0; i < service.columns.length; i++) {\n      for (var j = 0; j < service.columns[i].queries.length; j++) {\n        if (service.columns[i].queries[j].hash === queryHash) {\n          return new Promise(function (resolve, reject) { // eslint-disable-line no-loop-func\n            try {\n              resolve(service.columns[i].queries[j])\n            } catch (err) {\n              reject(err)\n            }\n          })\n        }\n      }\n    }\n\n    var query = {\n      // Original query passed in to query method\n      original: queryObj,\n      hash: queryHash,\n    }\n\n    // Default queryObj\n    if (_.isUndefined(query.original)) {\n      query.original = {}\n    }\n    // Default select\n    if (_.isUndefined(query.original.select)) {\n      query.original.select = {\n        $count: true,\n      }\n    }\n    // Default to groupAll\n    query.original.groupBy = query.original.groupBy || true\n\n    // Attach the query api to the query object\n    query = newQueryObj(query)\n\n    return createColumn(query)\n      .then(makeCrossfilterGroup)\n      .then(buildRequiredColumns)\n      .then(setupDataListeners)\n      .then(applyQuery)\n\n    function createColumn(query) {\n      // Ensure column is created\n      return service.column({\n        key: query.original.groupBy,\n        type: _.isUndefined(query.type) ? null : query.type,\n        array: Boolean(query.array),\n      })\n        .then(function () {\n        // Attach the column to the query\n          var column = service.column.find(query.original.groupBy)\n          query.column = column\n          column.queries.push(query)\n          column.removeListeners.push(function () {\n            return query.clear()\n          })\n          return query\n        })\n    }\n\n    function makeCrossfilterGroup(query) {\n      // Create the grouping on the columns dimension\n      // Using Promise Resolve allows support for crossfilter async\n      // TODO check if query already exists, and use the same base query // if possible\n      return Promise.resolve(query.column.dimension.group())\n        .then(function (g) {\n          query.group = g\n          return query\n        })\n    }\n\n    function buildRequiredColumns(query) {\n      var requiredColumns = filters.scanForDynamicFilters(query.original)\n      // We need to scan the group for any filters that would require\n      // the group to be rebuilt when data is added or removed in any way.\n      if (requiredColumns.length) {\n        return Promise.all(_.map(requiredColumns, function (columnKey) {\n          return service.column({\n            key: columnKey,\n            dynamicReference: query.group,\n          })\n        }))\n          .then(function () {\n            return query\n          })\n      }\n      return query\n    }\n\n    function setupDataListeners(query) {\n      // Here, we create a listener to recreate and apply the reducer to\n      // the group anytime underlying data changes\n      var stopDataListen = service.onDataChange(function () {\n        return applyQuery(query)\n      })\n      query.removeListeners.push(stopDataListen)\n\n      // This is a similar listener for filtering which will (if needed)\n      // run any post aggregations on the data after each filter action\n      var stopFilterListen = service.onFilter(function () {\n        return postAggregate(query)\n      })\n      query.removeListeners.push(stopFilterListen)\n\n      return query\n    }\n\n    function applyQuery(query) {\n      return buildReducer(query)\n        .then(applyReducer)\n        .then(attachData)\n        .then(postAggregate)\n    }\n\n    function buildReducer(query) {\n      return reductiofy(query.original)\n        .then(function (reducer) {\n          query.reducer = reducer\n          return query\n        })\n    }\n\n    function applyReducer(query) {\n      return Promise.resolve(query.reducer(query.group))\n        .then(function () {\n          return query\n        })\n    }\n\n    function attachData(query) {\n      return Promise.resolve(query.group.all())\n        .then(function (data) {\n          query.data = data\n          return query\n        })\n    }\n\n    function postAggregate(query) {\n      if (query.postAggregations.length > 1) {\n        // If the query is used by 2+ post aggregations, we need to lock\n        // it against getting mutated by the post-aggregations\n        query.locked = true\n      }\n      return Promise.all(_.map(query.postAggregations, function (post) {\n        return post()\n      }))\n        .then(function () {\n          return query\n        })\n    }\n\n    function newQueryObj(q, parent) {\n      var locked = false\n      if (!parent) {\n        parent = q\n        q = {}\n        locked = true\n      }\n\n      // Assign the regular query properties\n      _.assign(q, {\n        // The Universe for continuous promise chaining\n        universe: service,\n        // Crossfilter instance\n        crossfilter: service.cf,\n\n        // parent Information\n        parent: parent,\n        column: parent.column,\n        dimension: parent.dimension,\n        group: parent.group,\n        reducer: parent.reducer,\n        original: parent.original,\n        hash: parent.hash,\n\n        // It's own removeListeners\n        removeListeners: [],\n\n        // It's own postAggregations\n        postAggregations: [],\n\n        // Data method\n        locked: locked,\n        lock: lock,\n        unlock: unlock,\n        // Disposal method\n        clear: clearQuery,\n      })\n\n      _.forEach(postAggregationMethods, function (method) {\n        q[method] = postAggregateMethodWrap(postAggregation[method])\n      })\n\n      return q\n\n      function lock(set) {\n        if (!_.isUndefined(set)) {\n          q.locked = Boolean(set)\n          return\n        }\n        q.locked = true\n      }\n\n      function unlock() {\n        q.locked = false\n      }\n\n      function clearQuery() {\n        _.forEach(q.removeListeners, function (l) {\n          l()\n        })\n        return new Promise(function (resolve, reject) {\n          try {\n            resolve(q.group.dispose())\n          } catch (err) {\n            reject(err)\n          }\n        })\n          .then(function () {\n            q.column.queries.splice(q.column.queries.indexOf(q), 1)\n            // Automatically recycle the column if there are no queries active on it\n            if (!q.column.queries.length) {\n              return service.clear(q.column.key)\n            }\n          })\n          .then(function () {\n            return service\n          })\n      }\n\n      function postAggregateMethodWrap(postMethod) {\n        return function () {\n          var args = Array.prototype.slice.call(arguments)\n          var sub = {}\n          newQueryObj(sub, q)\n          args.unshift(sub, q)\n\n          q.postAggregations.push(function () {\n            Promise.resolve(postMethod.apply(null, args))\n              .then(postAggregateChildren)\n          })\n\n          return Promise.resolve(postMethod.apply(null, args))\n            .then(postAggregateChildren)\n\n          function postAggregateChildren() {\n            return postAggregate(sub)\n              .then(function () {\n                return sub\n              })\n          }\n        }\n      }\n    }\n  }\n}\n","'use strict'\n\n// var _ = require('./lodash') // _ is defined but never used\n\nmodule.exports = {\n  shorthandLabels: {\n    $count: 'count',\n    $sum: 'sum',\n    $avg: 'avg',\n    $min: 'min',\n    $max: 'max',\n    $med: 'med',\n    $sumSq: 'sumSq',\n    $std: 'std',\n  },\n  aggregators: {\n    $count: $count,\n    $sum: $sum,\n    $avg: $avg,\n    $min: $min,\n    $max: $max,\n    $med: $med,\n    $sumSq: $sumSq,\n    $std: $std,\n    $valueList: $valueList,\n    $dataList: $dataList,\n  },\n}\n\n// Aggregators\n\nfunction $count(reducer/* , value */) {\n  return reducer.count(true)\n}\n\nfunction $sum(reducer, value) {\n  return reducer.sum(value)\n}\n\nfunction $avg(reducer, value) {\n  return reducer.avg(value)\n}\n\nfunction $min(reducer, value) {\n  return reducer.min(value)\n}\n\nfunction $max(reducer, value) {\n  return reducer.max(value)\n}\n\nfunction $med(reducer, value) {\n  return reducer.median(value)\n}\n\nfunction $sumSq(reducer, value) {\n  return reducer.sumOfSq(value)\n}\n\nfunction $std(reducer, value) {\n  return reducer.std(value)\n}\n\nfunction $valueList(reducer, value) {\n  return reducer.valueList(value)\n}\n\nfunction $dataList(reducer/* , value */) {\n  return reducer.dataList(true)\n}\n\n// TODO histograms\n// TODO exceptions\n","'use strict'\n\nvar reductio = require('reductio')\n\nvar _ = require('./lodash')\nvar rAggregators = require('./reductioAggregators')\n// var expressions = require('./expressions')  // exporession is defined but never used\nvar aggregation = require('./aggregation')\n\nmodule.exports = function (service) {\n  var filters = require('./filters')(service)\n\n  return function reductiofy(query) {\n    var reducer = reductio()\n    // var groupBy = query.groupBy // groupBy is defined but never used\n    aggregateOrNest(reducer, query.select)\n\n    if (query.filter) {\n      var filterFunction = filters.makeFunction(query.filter)\n      if (filterFunction) {\n        reducer.filter(filterFunction)\n      }\n    }\n\n    return Promise.resolve(reducer)\n\n    // This function recursively find the first level of reductio methods in\n    // each object and adds that reduction method to reductio\n    function aggregateOrNest(reducer, selects) {\n      // Sort so nested values are calculated last by reductio's .value method\n      var sortedSelectKeyValue = _.sortBy(\n        _.map(selects, function (val, key) {\n          return {\n            key: key,\n            value: val,\n          }\n        }),\n        function (s) {\n          if (rAggregators.aggregators[s.key]) {\n            return 0\n          }\n          return 1\n        })\n\n      // dive into each key/value\n      return _.forEach(sortedSelectKeyValue, function (s) {\n        // Found a Reductio Aggregation\n        if (rAggregators.aggregators[s.key]) {\n          // Build the valueAccessorFunction\n          var accessor = aggregation.makeValueAccessor(s.value)\n          // Add the reducer with the ValueAccessorFunction to the reducer\n          reducer = rAggregators.aggregators[s.key](reducer, accessor)\n          return\n        }\n\n        // Found a top level key value that is not an aggregation or a\n        // nested object. This is unacceptable.\n        if (!_.isObject(s.value)) {\n          console.error('Nested selects must be an object', s.key)\n          return\n        }\n\n        // It's another nested object, so just repeat this process on it\n        aggregateOrNest(reducer.value(s.key), s.value)\n      })\n    }\n  }\n}\n","'use strict'\n\nvar _ = require('./lodash')\n\nmodule.exports = universe\n\nfunction universe(data, options) {\n  var service = {\n    options: _.assign({}, options),\n    columns: [],\n    filters: {},\n    dataListeners: [],\n    filterListeners: [],\n  }\n\n  var cf = require('./crossfilter')(service)\n  var filters = require('./filters')(service)\n\n  data = cf.generateColumns(data)\n\n  return cf.build(data)\n    .then(function (data) {\n      service.cf = data\n      return _.assign(service, {\n        add: cf.add,\n        remove: cf.remove,\n        column: require('./column')(service),\n        query: require('./query')(service),\n        filter: filters.filter,\n        filterAll: filters.filterAll,\n        applyFilters: filters.applyFilters,\n        clear: require('./clear')(service),\n        destroy: require('./destroy')(service),\n        onDataChange: onDataChange,\n        onFilter: onFilter,\n      })\n    })\n\n  function onDataChange(cb) {\n    service.dataListeners.push(cb)\n    return function () {\n      service.dataListeners.splice(service.dataListeners.indexOf(cb), 1)\n    }\n  }\n\n  function onFilter(cb) {\n    service.filterListeners.push(cb)\n    return function () {\n      service.filterListeners.splice(service.filterListeners.indexOf(cb), 1)\n    }\n  }\n}\n"]} diff --git a/universe.min.js b/universe.min.js new file mode 100644 index 0000000..e5efa80 --- /dev/null +++ b/universe.min.js @@ -0,0 +1,4 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.universe=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o=length)return array;var copy=new array.constructor(length);copy.set(array);return copy};var crossfilter_arrayWiden=function(array,width){var copy;switch(width){case 16:copy=crossfilter_array16(array.length);break;case 32:copy=crossfilter_array32(array.length);break;default:throw new Error("invalid array width!")}copy.set(array);return copy}}function crossfilter_arrayUntyped(n){var array=new Array(n),i=-1;while(++i32)throw new Error("invalid array width!");return array}function crossfilter_bitarray(n){this.length=n;this.subarrays=1;this.width=8;this.masks={0:0};this[0]=crossfilter_array8(n)}crossfilter_bitarray.prototype.lengthen=function(n){var i,len;for(i=0,len=this.subarrays;i=32&&!one){continue}if(w<32&&one&1<=n;j--){this[i][j]=0}this[i].length=n}this.length=n};crossfilter_bitarray.prototype.zero=function(n){var i,len;for(i=0,len=this.subarrays;i>>1;if(f(a[mid])>>1;if(x>7]&=~(1<<(id&63))}}return filters.zeroExceptMask(i,mask)}function dimension(value,iterable){if(typeof value==="string"){var accessorPath=value;value=function(d){return result(d,accessorPath)}}var dimension={filter:filter,filterExact:filterExact,filterRange:filterRange,filterFunction:filterFunction,filterAll:filterAll,top:top,bottom:bottom,group:group,groupAll:groupAll,dispose:dispose,remove:dispose,accessor:value,id:function(){return id}};var one,zero,offset,id,values,index,newValues,newIndex,iterablesIndexCount,newIterablesIndexCount,iterablesIndexFilterStatus,newIterablesIndexFilterStatus,iterablesEmptyRows=[],sort=quicksort.by(function(i){return newValues[i]}),refilter=xfilterFilter.filterAll,refilterFunction,indexListeners=[],dimensionGroups=[],lo0=0,hi0=0,t=0,k;dataListeners.unshift(preAdd);dataListeners.push(postAdd);removeDataListeners.push(removeData);var tmp=filters.add();offset=tmp.offset;one=tmp.one;zero=~one;id=offset<<7|Math.log(one)/Math.log(2);preAdd(data,0,n);postAdd(data,0,n);function preAdd(newData,n0,n1){if(iterable){t=0;j=0;k=[];for(var i0=0;i0lo0){for(i=lo0,j=Math.min(lo1,hi0);ihi0){for(i=Math.max(lo1,hi0),j=hi1;i0)toSkip=top_offset;while(--i>=lo0&&k>0){if(filters.zero(j=index[i])){if(toSkip>0){--toSkip}else{array.push(data[j]);--k}}}if(iterable){for(i=0;i0;i++){if(filters.zero(j=iterablesEmptyRows[i])){if(toSkip>0){--toSkip}else{array.push(data[j]);--k}}}}return array}function bottom(k,bottom_offset){var array=[],i,j,toSkip=0;if(bottom_offset&&bottom_offset>0)toSkip=bottom_offset;if(iterable){for(i=0;i0;i++){if(filters.zero(j=iterablesEmptyRows[i])){if(toSkip>0){--toSkip}else{array.push(data[j]);--k}}}}i=lo0;while(i0){if(filters.zero(j=index[i])){if(toSkip>0){--toSkip}else{array.push(data[j]);--k}}i++}return array}function group(key){var group={top:top,all:all,reduce:reduce,reduceCount:reduceCount,reduceSum:reduceSum,order:order,orderNatural:orderNatural,size:size,dispose:dispose,remove:dispose};dimensionGroups.push(group);var groups,groupIndex,groupWidth=8,groupCapacity=crossfilter_capacity(groupWidth),k=0,select,heap,reduceAdd,reduceRemove,reduceInitial,update=crossfilter_null,reset=crossfilter_null,resetNeeded=true,groupAll=key===crossfilter_null,n0old;if(arguments.length<1)key=crossfilter_identity;filterListeners.push(update);indexListeners.push(add);removeDataListeners.push(removeData);add(values,index,0,n);function add(newValues,newIndex,n0,n1){if(iterable){n0old=n0;n0=values.length-newValues.length;n1=newValues.length}var oldGroups=groups,reIndex=iterable?[]:crossfilter_index(k,groupCapacity),add=reduceAdd,remove=reduceRemove,initial=reduceInitial,k0=k,i0=0,i1=0,j,g0,x0,x1,g,x;if(resetNeeded)add=initial=crossfilter_null;if(resetNeeded)remove=initial=crossfilter_null;groups=new Array(k),k=0;if(iterable){groupIndex=k0?groupIndex:[]}else{groupIndex=k0>1?xfilterArray.arrayLengthen(groupIndex,n):crossfilter_index(n,groupCapacity)}if(k0)x0=(g0=oldGroups[0]).key;while(i1=x1))++i1;while(i1=n1)break;x1=key(newValues[i1])}groupIncrement()}while(i0i0){if(iterable){for(i0=0;i01||iterable){update=updateMany;reset=resetMany}else{if(!k&&groupAll){k=1;groups=[{key:null,value:initial()}]}if(k===1){update=updateOne;reset=resetOne}else{update=crossfilter_null;reset=crossfilter_null}groupIndex=null}filterListeners[j]=update;function groupIncrement(){if(iterable){k++;return}if(++k===groupCapacity){reIndex=xfilterArray.arrayWiden(reIndex,groupWidth<<=1);groupIndex=xfilterArray.arrayWiden(groupIndex,groupWidth);groupCapacity=crossfilter_capacity(groupWidth)}}}function removeData(reIndex){if(k>1||iterable){var oldK=k,oldGroups=groups,seenGroups=crossfilter_index(oldK,oldK),i,i0,j;if(!iterable){for(i=0,j=0;i1||iterable){if(!iterable){for(i=0;i1||iterable?(reset=resetMany,update=updateMany):k===1?(reset=resetOne,update=updateOne):reset=update=crossfilter_null}else if(k===1){if(groupAll)return;for(var index3=0;index3=0)filterListeners.splice(i,1);i=indexListeners.indexOf(add);if(i>=0)indexListeners.splice(i,1);i=removeDataListeners.indexOf(removeData);if(i>=0)removeDataListeners.splice(i,1);return group}return reduceCount().orderNatural()}function groupAll(){var g=group(crossfilter_null),all=g.all;delete g.all;delete g.top;delete g.order;delete g.orderNatural;delete g.size;g.value=function(){return all()[0].value};return g}function dispose(){dimensionGroups.forEach(function(group){group.dispose()});var i=dataListeners.indexOf(preAdd);if(i>=0)dataListeners.splice(i,1);i=dataListeners.indexOf(postAdd);if(i>=0)dataListeners.splice(i,1);i=removeDataListeners.indexOf(removeData);if(i>=0)removeDataListeners.splice(i,1);filters.masks[offset]&=zero;return filterAll()}return dimension}function groupAll(){var group={reduce:reduce,reduceCount:reduceCount,reduceSum:reduceSum,value:value,dispose:dispose,remove:dispose};var reduceValue,reduceAdd,reduceRemove,reduceInitial,resetNeeded=true;filterListeners.push(update);dataListeners.push(add);add(data,0,n);function add(newData,n0){var i;if(resetNeeded)return;for(i=n0;i=0)filterListeners.splice(i,1);i=dataListeners.indexOf(add);if(i>=0)dataListeners.splice(i,1);return group}return reduceCount()}function size(){return n}function all(){return data}function allFiltered(){var array=[],i=0;for(i=0;i>>1)+1;while(--i>0)sift(a,i,n,lo);return a}function sort(a,lo,hi){var n=hi-lo,t;while(--n>0)t=a[lo],a[lo]=a[lo+n],a[lo+n]=t,sift(a,1,n,lo);return a}function sift(a,i,n,lo){var d=a[--lo+i],x=f(d),child;while((child=i<<1)<=n){if(childf(a[lo+child+1]))child++;if(x<=f(a[lo+child]))break;a[lo+i]=a[lo+child];i=child}a[lo+i]=d}heap.sort=sort;return heap}module.exports=heap_by(crossfilter_identity);module.exports.by=heap_by},{"./identity":9}],8:[function(require,module,exports){"use strict";var crossfilter_identity=require("./identity");var xFilterHeap=require("./heap");function heapselect_by(f){var heap=xFilterHeap.by(f);function heapselect(a,lo,hi,k){var queue=new Array(k=Math.min(hi-lo,k)),min,i,d;for(i=0;imin){queue[0]=d;min=f(heap(queue,0,k)[0])}}while(++lolo&&f(a[j-1])>x;--j){a[j]=a[j-1]}a[j]=t}return a}return insertionsort}module.exports=insertionsort_by(crossfilter_identity);module.exports.by=insertionsort_by},{"./identity":9}],11:[function(require,module,exports){"use strict";function crossfilter_null(){return null}module.exports=crossfilter_null},{}],12:[function(require,module,exports){"use strict" +;function permute(array,index,deep){for(var i=0,n=index.length,copy=deep?JSON.parse(JSON.stringify(array)):new Array(n);i>1,i2=i3-sixth,i4=i3+sixth;var e1=a[i1],x1=f(e1),e2=a[i2],x2=f(e2),e3=a[i3],x3=f(e3),e4=a[i4],x4=f(e4),e5=a[i5],x5=f(e5);var t;if(x1>x2)t=e1,e1=e2,e2=t,t=x1,x1=x2,x2=t;if(x4>x5)t=e4,e4=e5,e5=t,t=x4,x4=x5,x5=t;if(x1>x3)t=e1,e1=e3,e3=t,t=x1,x1=x3,x3=t;if(x2>x3)t=e2,e2=e3,e3=t,t=x2,x2=x3,x3=t;if(x1>x4)t=e1,e1=e4,e4=t,t=x1,x1=x4,x4=t;if(x3>x4)t=e3,e3=e4,e4=t,t=x3,x3=x4,x4=t;if(x2>x5)t=e2,e2=e5,e5=t,t=x2,x2=x5,x5=t;if(x2>x3)t=e2,e2=e3,e3=t,t=x2,x2=x3,x3=t;if(x4>x5)t=e4,e4=e5,e5=t,t=x4,x4=x5,x5=t;var pivot1=e2,pivotValue1=x2,pivot2=e4,pivotValue2=x4;a[i1]=e1;a[i2]=a[lo];a[i3]=e3;a[i4]=a[hi-1];a[i5]=e5;var less=lo+1,great=hi-2;var pivotsEqual=pivotValue1<=pivotValue2&&pivotValue1>=pivotValue2;if(pivotsEqual){for(var k=less;k<=great;++k){var ek=a[k],xk=f(ek);if(xkpivotValue1){while(true){var greatValue=f(a[great]);if(greatValue>pivotValue1){great--;continue}else if(greatValuepivotValue2){while(true){var greatValue=f(a[great]);if(greatValue>pivotValue2){great--;if(greati5){(function(){var lessValue,greatValue;while((lessValue=f(a[less]))<=pivotValue1&&lessValue>=pivotValue1)++less;while((greatValue=f(a[great]))<=pivotValue2&&greatValue>=pivotValue2)--great;for(var k=less;k<=great;k++){var ek=a[k],xk=f(ek);if(xk<=pivotValue1&&xk>=pivotValue1){if(k!==less){a[k]=a[less];a[less]=ek}less++}else{if(xk<=pivotValue2&&xk>=pivotValue2){while(true){greatValue=f(a[great]);if(greatValue<=pivotValue2&&greatValue>=pivotValue2){great--;if(great-1}function listCacheSet(key,value){var data=this.__data__,index=assocIndexOf(data,key);if(index<0){data.push([key,value])}else{data[index][1]=value}return this}ListCache.prototype.clear=listCacheClear;ListCache.prototype["delete"]=listCacheDelete;ListCache.prototype.get=listCacheGet;ListCache.prototype.has=listCacheHas;ListCache.prototype.set=listCacheSet;function MapCache(entries){var index=-1,length=entries?entries.length:0;this.clear();while(++index0){path(p).avg=path(p).sum/path(p).count}else{path(p).avg=0}return p}},remove:function(a,prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);if(path(p).count>0){path(p).avg=path(p).sum/path(p).count}else{path(p).avg=0}return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).avg=0;return p}}};module.exports=reductio_avg},{}],21:[function(require,module,exports){var reductio_filter=require("./filter.js");var reductio_count=require("./count.js");var reductio_sum=require("./sum.js");var reductio_avg=require("./avg.js");var reductio_median=require("./median.js");var reductio_min=require("./min.js");var reductio_max=require("./max.js");var reductio_value_count=require("./value-count.js");var reductio_value_list=require("./value-list.js");var reductio_exception_count=require("./exception-count.js");var reductio_exception_sum=require("./exception-sum.js");var reductio_histogram=require("./histogram.js");var reductio_sum_of_sq=require("./sum-of-squares.js");var reductio_std=require("./std.js");var reductio_nest=require("./nest.js");var reductio_alias=require("./alias.js");var reductio_alias_prop=require("./aliasProp.js");var reductio_data_list=require("./data-list.js");var reductio_custom=require("./custom.js");function build_function(p,f,path){if(!path)path=function(d){return d};var origF={reduceAdd:f.reduceAdd,reduceRemove:f.reduceRemove,reduceInitial:f.reduceInitial};if(p.count||p.std){f.reduceAdd=reductio_count.add(f.reduceAdd,path,p.count);f.reduceRemove=reductio_count.remove(f.reduceRemove,path,p.count);f.reduceInitial=reductio_count.initial(f.reduceInitial,path,p.count)}if(p.sum){f.reduceAdd=reductio_sum.add(p.sum,f.reduceAdd,path);f.reduceRemove=reductio_sum.remove(p.sum,f.reduceRemove,path);f.reduceInitial=reductio_sum.initial(f.reduceInitial,path)}if(p.avg){if(!p.count||!p.sum){console.error("You must set .count(true) and define a .sum(accessor) to use .avg(true).")}else{f.reduceAdd=reductio_avg.add(p.sum,f.reduceAdd,path);f.reduceRemove=reductio_avg.remove(p.sum,f.reduceRemove,path);f.reduceInitial=reductio_avg.initial(f.reduceInitial,path)}}if(p.exceptionCount){if(!p.exceptionAccessor){console.error("You must define an .exception(accessor) to use .exceptionCount(true).")}else{f.reduceAdd=reductio_exception_count.add(p.exceptionAccessor,f.reduceAdd,path);f.reduceRemove=reductio_exception_count.remove(p.exceptionAccessor,f.reduceRemove,path);f.reduceInitial=reductio_exception_count.initial(f.reduceInitial,path)}}if(p.exceptionSum){if(!p.exceptionAccessor){console.error("You must define an .exception(accessor) to use .exceptionSum(accessor).")}else{f.reduceAdd=reductio_exception_sum.add(p.exceptionAccessor,p.exceptionSum,f.reduceAdd,path);f.reduceRemove=reductio_exception_sum.remove(p.exceptionAccessor,p.exceptionSum,f.reduceRemove,path);f.reduceInitial=reductio_exception_sum.initial(f.reduceInitial,path)}}if(p.valueList||p.median||p.min||p.max){f.reduceAdd=reductio_value_list.add(p.valueList,f.reduceAdd,path);f.reduceRemove=reductio_value_list.remove(p.valueList,f.reduceRemove,path);f.reduceInitial=reductio_value_list.initial(f.reduceInitial,path)}if(p.dataList){f.reduceAdd=reductio_data_list.add(p.dataList,f.reduceAdd,path);f.reduceRemove=reductio_data_list.remove(p.dataList,f.reduceRemove,path);f.reduceInitial=reductio_data_list.initial(f.reduceInitial,path)}if(p.median){f.reduceAdd=reductio_median.add(f.reduceAdd,path);f.reduceRemove=reductio_median.remove(f.reduceRemove,path);f.reduceInitial=reductio_median.initial(f.reduceInitial,path)}if(p.min){f.reduceAdd=reductio_min.add(f.reduceAdd,path);f.reduceRemove=reductio_min.remove(f.reduceRemove,path);f.reduceInitial=reductio_min.initial(f.reduceInitial,path)}if(p.max){f.reduceAdd=reductio_max.add(f.reduceAdd,path);f.reduceRemove=reductio_max.remove(f.reduceRemove,path);f.reduceInitial=reductio_max.initial(f.reduceInitial,path)}if(p.exceptionAccessor){f.reduceAdd=reductio_value_count.add(p.exceptionAccessor,f.reduceAdd,path);f.reduceRemove=reductio_value_count.remove(p.exceptionAccessor,f.reduceRemove,path);f.reduceInitial=reductio_value_count.initial(f.reduceInitial,path)}if(p.histogramValue&&p.histogramThresholds){f.reduceAdd=reductio_histogram.add(p.histogramValue,f.reduceAdd,path);f.reduceRemove=reductio_histogram.remove(p.histogramValue,f.reduceRemove,path);f.reduceInitial=reductio_histogram.initial(p.histogramThresholds,f.reduceInitial,path)}if(p.sumOfSquares){f.reduceAdd=reductio_sum_of_sq.add(p.sumOfSquares,f.reduceAdd,path);f.reduceRemove=reductio_sum_of_sq.remove(p.sumOfSquares,f.reduceRemove,path);f.reduceInitial=reductio_sum_of_sq.initial(f.reduceInitial,path)}if(p.std){if(!p.sumOfSquares||!p.sum){console.error("You must set .sumOfSq(accessor) and define a .sum(accessor) to use .std(true). Or use .std(accessor).")}else{f.reduceAdd=reductio_std.add(f.reduceAdd,path);f.reduceRemove=reductio_std.remove(f.reduceRemove,path);f.reduceInitial=reductio_std.initial(f.reduceInitial,path)}}if(p.custom){f.reduceAdd=reductio_custom.add(f.reduceAdd,path,p.custom.add);f.reduceRemove=reductio_custom.remove(f.reduceRemove,path,p.custom.remove);f.reduceInitial=reductio_custom.initial(f.reduceInitial,path,p.custom.initial)}if(p.nestKeys){f.reduceAdd=reductio_nest.add(p.nestKeys,f.reduceAdd,path);f.reduceRemove=reductio_nest.remove(p.nestKeys,f.reduceRemove,path);f.reduceInitial=reductio_nest.initial(f.reduceInitial,path)}if(p.aliasKeys){f.reduceInitial=reductio_alias.initial(f.reduceInitial,path,p.aliasKeys)}if(p.aliasPropKeys){f.reduceAdd=reductio_alias_prop.add(p.aliasPropKeys,f.reduceAdd,path);f.reduceRemove=reductio_alias_prop.add(p.aliasPropKeys,f.reduceRemove,path)}if(p.filter){f.reduceAdd=reductio_filter.add(p.filter,f.reduceAdd,origF.reduceAdd,path);f.reduceRemove=reductio_filter.remove(p.filter,f.reduceRemove,origF.reduceRemove,path)}if(p.values){Object.getOwnPropertyNames(p.values).forEach(function(n){var setupPath=function(prior){return function(p){p=prior(p);path(p)[n]={};return p}};f.reduceInitial=setupPath(f.reduceInitial);build_function(p.values[n].parameters,f,function(p){return p[n]})})}}var reductio_build={build:build_function};module.exports=reductio_build},{"./alias.js":18,"./aliasProp.js":19,"./avg.js":20,"./count.js":23,"./custom.js":24,"./data-list.js":25,"./exception-count.js":26,"./exception-sum.js":27,"./filter.js":28,"./histogram.js":29,"./max.js":30,"./median.js":31,"./min.js":32,"./nest.js":33,"./std.js":39,"./sum-of-squares.js":40,"./sum.js":41,"./value-count.js":42,"./value-list.js":43}],22:[function(require,module,exports){var pluck=function(n){return function(d){return d[n]}};_grouper=function(path,prior){if(!path)path=function(d){return d};return function(p,v){if(prior)prior(p,v);var x=path(p),y=path(v);if(typeof y.count!=="undefined")x.count+=y.count;if(typeof y.sum!=="undefined")x.sum+=y.sum;if(typeof y.avg!=="undefined")x.avg=x.sum/x.count;return p}};reductio_cap=function(prior,f,p){var obj=f.reduceInitial();var values=p.values?Object.keys(p.values):[];var _othersGrouper=_grouper();if(values.length){for(var i=0;ib?1:a>=b?0:NaN}var comparer=function(accessor,ordering){return function(a,b){return ordering(accessor(a),accessor(b))}};var type={}.toString;module.exports=function(prior){return function(value,order){if(arguments.length===1){order=ascending}return prior().sort(comparer(pluck_n(value),order))}}},{}],39:[function(require,module,exports){var reductio_std={add:function(prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);if(path(p).count>0){path(p).std=0;var n=path(p).sumOfSq-path(p).sum*path(p).sum/path(p).count;if(n>0)path(p).std=Math.sqrt(n/(path(p).count-1))}else{path(p).std=0}return p}},remove:function(prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);if(path(p).count>0){path(p).std=0;var n=path(p).sumOfSq-path(p).sum*path(p).sum/path(p).count;if(n>0)path(p).std=Math.sqrt(n/(path(p).count-1))}else{path(p).std=0}return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).std=0;return p}}};module.exports=reductio_std},{}],40:[function(require,module,exports){var reductio_sum_of_sq={add:function(a,prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);path(p).sumOfSq=path(p).sumOfSq+a(v)*a(v);return p}},remove:function(a,prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);path(p).sumOfSq=path(p).sumOfSq-a(v)*a(v);return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).sumOfSq=0;return p}}};module.exports=reductio_sum_of_sq},{}],41:[function(require,module,exports){var reductio_sum={add:function(a,prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);path(p).sum=path(p).sum+a(v);return p}},remove:function(a,prior,path){return function(p,v,nf){if(prior)prior(p,v,nf);path(p).sum=path(p).sum-a(v);return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).sum=0;return p}}};module.exports=reductio_sum},{}],42:[function(require,module,exports){var crossfilter=require("crossfilter2");var reductio_value_count={add:function(a,prior,path){var i,curr;return function(p,v,nf){if(prior)prior(p,v,nf);i=path(p).bisect(path(p).values,a(v),0,path(p).values.length);curr=path(p).values[i];if(curr&&curr[0]===a(v)){curr[1]++}else{path(p).values.splice(i,0,[a(v),1])}return p}},remove:function(a,prior,path){var i;return function(p,v,nf){if(prior)prior(p,v,nf);i=path(p).bisect(path(p).values,a(v),0,path(p).values.length);path(p).values[i][1]--;return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).values=[];path(p).bisect=crossfilter.bisect.by(function(d){return d[0]}).left;return p}}};module.exports=reductio_value_count},{crossfilter2:1}],43:[function(require,module,exports){var crossfilter=require("crossfilter2");var reductio_value_list={add:function(a,prior,path){var i;var bisect=crossfilter.bisect.by(function(d){return d}).left;return function(p,v,nf){if(prior)prior(p,v,nf);i=bisect(path(p).valueList,a(v),0,path(p).valueList.length);path(p).valueList.splice(i,0,a(v));return p}},remove:function(a,prior,path){var i;var bisect=crossfilter.bisect.by(function(d){return d}).left;return function(p,v,nf){if(prior)prior(p,v,nf);i=bisect(path(p).valueList,a(v),0,path(p).valueList.length);path(p).valueList.splice(i,1);return p}},initial:function(prior,path){return function(p){p=prior(p);path(p).valueList=[];return p}}};module.exports=reductio_value_list},{crossfilter2:1}],44:[function(require,module,exports){"use strict";var _=require("./lodash");var aggregators={$sum:$sum,$avg:$avg,$max:$max,$min:$min,$count:$count,$first:$first,$last:$last,$get:$get,$nth:$get,$nthLast:$nthLast,$nthPct:$nthPct,$map:$map};module.exports={makeValueAccessor:makeValueAccessor,aggregators:aggregators,extractKeyValOrArray:extractKeyValOrArray,parseAggregatorParams:parseAggregatorParams};function makeValueAccessor(obj){if(typeof obj==="string"){if(isStringSyntax(obj)){obj=convertAggregatorString(obj)}else{return obj}}if(typeof obj==="number"){return obj}if(_.isObject(obj)){return make()}function make(){var stack=makeSubAggregationFunction(obj);return function topStack(d){return stack(d)}}}function makeSubAggregationFunction(obj){obj=_.isObject(obj)?extractKeyValOrArray(obj):obj;if(_.isString(obj)){if(isStringSyntax(obj)){return makeSubAggregationFunction(convertAggregatorString(obj))}return function identity(d){return d[obj]}}if(_.isArray(obj)){var subStack=_.map(obj,makeSubAggregationFunction);return function getSubStack(d){return subStack.map(function(s){return s(d)})}}if(obj.key){if(aggregators[obj.key]){var subAggregationFunction=makeSubAggregationFunction(obj.value);return function getAggregation(d){return aggregators[obj.key](subAggregationFunction(d))}}console.error("Could not find aggregration method",obj)}return[]}function extractKeyValOrArray(obj){var keyVal;var values=[];for(var key in obj){if({}.hasOwnProperty.call(obj,key)){keyVal={key:key,value:obj[key]};var subObj={};subObj[key]=obj[key];values.push(subObj)}}return values.length>1?values:keyVal}function isStringSyntax(str){return["$","("].indexOf(str.charAt(0))>-1}function parseAggregatorParams(keyString){var params=[];var p1=keyString.indexOf("(");var p2=keyString.indexOf(")");var key=p1>-1?keyString.substring(0,p1):keyString;if(!aggregators[key]){return false}if(p1>-1&&p2>-1&&p2>p1){params=keyString.substring(p1+1,p2).split(",")}return{aggregator:aggregators[key],params:params}}function convertAggregatorString(keyString){var outerParens=/\((.+)\)/g;var hasComma=/(?:\([^\(\)]*\))|(,)/g;return JSON.parse("{"+unwrapParensAndCommas(keyString)+"}");function unwrapParensAndCommas(str){str=str.replace(" ","");return'"'+str.replace(outerParens,function(p,pr){if(hasComma.test(pr)){if(pr.charAt(0)==="$"){return'":{"'+pr.replace(hasComma,function(p2){if(p2===","){return',"'}return unwrapParensAndCommas(p2).trim()})+"}"}return':["'+pr.replace(hasComma,function(){return'","'})+'"]'}})}}function $sum(children){return children.reduce(function(a,b){return a+b},0)}function $avg(children){return children.reduce(function(a,b){return a+b},0)/children.length}function $max(children){return Math.max.apply(null,children)}function $min(children){return Math.min.apply(null,children)}function $count(children){return children.length}function $first(children){return children[0]}function $last(children){return children[children.length-1]}function $get(children,n){return children[n]}function $nthLast(children,n){return children[children.length-n]}function $nthPct(children,n){return children[Math.round(children.length*(n/100))]}function $map(children,n){return children.map(function(d){return d[n]})}},{"./lodash":52}],45:[function(require,module,exports){"use strict";var _=require("./lodash");module.exports=function(service){return function clear(def){if(def){def=_.isArray(def)?def:[def]}if(!def){return Promise.all(_.map(service.columns,disposeColumn)).then(function(){service.columns=[];return service})}return Promise.all(_.map(def,function(d){if(_.isObject(d)){d=d.key}var column=_.remove(service.columns,function(c){if(_.isArray(d)){return!_.xor(c.key,d).length}if(c.key===d){if(c.dynamicReference){return false}return true}})[0];if(!column){return}disposeColumn(column)})).then(function(){return service});function disposeColumn(column){var disposalActions=[];if(column.removeListeners){disposalActions=_.map(column.removeListeners,function(listener){return Promise.resolve(listener())})}var filterKey=column.key;if(column.complex==="array"){filterKey=JSON.stringify(column.key)}if(column.complex==="function"){filterKey=column.key.toString()}delete service.filters[filterKey];if(column.dimension){disposalActions.push(Promise.resolve(column.dimension.dispose()))}return Promise.all(disposalActions)}}}},{"./lodash":52}],46:[function(require,module,exports){"use strict";var _=require("./lodash");module.exports=function(service){var dimension=require("./dimension")(service);var columnFunc=column;columnFunc.find=findColumn;return columnFunc;function column(def){if(_.isUndefined(def)){def=true}if(!_.isArray(def)){def=[def]}return Promise.all(_.map(def,makeColumn)).then(function(){return service})}function findColumn(d){return _.find(service.columns,function(c){if(_.isArray(d)){return!_.xor(c.key,d).length}return c.key===d})}function getType(d){if(_.isNumber(d)){return"number"}if(_.isBoolean(d)){return"bool"}if(_.isArray(d)){return"array"}if(_.isObject(d)){return"object"}return"string"}function makeColumn(d){var column=_.isObject(d)?d:{key:d};var existing=findColumn(column.key);if(existing){existing.temporary=false;if(existing.dynamicReference){existing.dynamicReference=false}return existing.promise.then(function(){return service})}column.queries=[];service.columns.push(column);column.promise=new Promise(function(resolve,reject){try{resolve(service.cf.all())}catch(err){reject(err)}}).then(function(all){var sample;if(_.isFunction(column.key)){column.complex="function";sample=column.key(all[0])}else if(_.isString(column.key)&&(column.key.indexOf(".")>-1||column.key.indexOf("[")>-1)){column.complex="string";sample=_.get(all[0],column.key)}else if(_.isArray(column.key)){column.complex="array";sample=_.values(_.pick(all[0],column.key));if(sample.length!==column.key.length){throw new Error("Column key does not exist in data!",column.key)}}else{sample=all[0][column.key]}if(!column.complex&&column.key!==true&&typeof sample==="undefined"){throw new Error("Column key does not exist in data!",column.key)}if(column.key===true){column.type="all"}else if(column.complex){column.type="complex"}else if(column.array){column.type="array"}else{column.type=getType(sample)}return dimension.make(column.key,column.type,column.complex)}).then(function(dim){column.dimension=dim;column.filterCount=0;var stopListeningForData=service.onDataChange(buildColumnKeys);column.removeListeners=[stopListeningForData];return buildColumnKeys();function buildColumnKeys(changes){if(column.key===true){return Promise.resolve()}var accessor=dimension.makeAccessor(column.key,column.complex);column.values=column.values||[];return new Promise(function(resolve,reject){try{if(changes&&changes.added){resolve(changes.added)}else{resolve(column.dimension.bottom(Infinity))}}catch(err){reject(err)}}).then(function(rows){var newValues;if(column.complex==="string"||column.complex==="function"){newValues=_.map(rows,accessor)}else if(column.type==="array"){newValues=_.flatten(_.map(rows,accessor))}else{newValues=_.map(rows,accessor)}column.values=_.uniq(column.values.concat(newValues))})}});return column.promise.then(function(){return service})}}},{"./dimension":49,"./lodash":52}],47:[function(require,module,exports){"use strict";var crossfilter=require("crossfilter2");var _=require("./lodash");module.exports=function(service){return{build:build,generateColumns:generateColumns,add:add,remove:remove};function build(c){if(_.isArray(c)){return Promise.resolve(crossfilter(c))}if(!c||typeof c.dimension!=="function"){return Promise.reject(new Error("No Crossfilter data or instance found!"))}return Promise.resolve(c)}function generateColumns(data){if(!service.options.generatedColumns){return data}return _.map(data,function(d){_.forEach(service.options.generatedColumns,function(val,key){d[key]=val(d)});return d})}function add(data){data=generateColumns(data);return new Promise(function(resolve,reject){try{resolve(service.cf.add(data))}catch(err){reject(err)}}).then(function(){return _.map(service.dataListeners,function(listener){return function(){return listener({added:data})}}).reduce(function(promise,data){return promise.then(data)},Promise.resolve(true))}).then(function(){return Promise.all(_.map(service.filterListeners,function(listener){return listener()}))}).then(function(){return service})}function remove(predicate){return new Promise(function(resolve,reject){try{resolve(service.cf.remove(predicate))}catch(err){reject(err)}}).then(function(){return Promise.all(_.map(service.filterListeners,function(listener){return listener()}))}).then(function(){return service})}}},{"./lodash":52,crossfilter2:1}],48:[function(require,module,exports){"use strict";module.exports=function(service){return function destroy(){return service.clear().then(function(){service.cf.dataListeners=[];service.cf.filterListeners=[];return Promise.resolve(service.cf.remove())}).then(function(){return service})}}},{}],49:[function(require,module,exports){"use strict";var _=require("./lodash");module.exports=function(service){return{make:make,makeAccessor:makeAccessor};function make(key,type,complex){var accessor=makeAccessor(key,complex);return Promise.resolve(service.cf.dimension(accessor,type==="array"))}function makeAccessor(key,complex){var accessorFunction;if(complex==="string"){accessorFunction=function(d){return _.get(d,key)}}else if(complex==="function"){accessorFunction=key}else if(complex==="array"){var arrayString=_.map(key,function(k){return"d['"+k+"']"});accessorFunction=new Function("d",String("return "+JSON.stringify(arrayString).replace(/"/g,"")))}else{accessorFunction=key===true?function accessor(d,i){return i}:function(d){return d[key]}}return accessorFunction}}},{"./lodash":52}],50:[function(require,module,exports){"use strict";module.exports={$field:$field,$and:$and,$or:$or,$not:$not,$eq:$eq,$gt:$gt,$gte:$gte,$lt:$lt,$lte:$lte,$ne:$ne,$type:$type,$in:$in,$nin:$nin,$contains:$contains,$excludes:$excludes,$size:$size};function $field(d,child){return d[child]}function $and(d,child){child=child(d);for(var i=0;ichild()}function $gte(d,child){return d>=child()}function $lt(d,child){return d-1}function $nin(d,child){return d.indexOf(child())===-1}function $contains(d,child){return child().indexOf(d)>-1}function $excludes(d,child){return child().indexOf(d)===-1}function $size(d,child){return d.length===child()}},{}],51:[function(require,module,exports){"use strict";var _=require("./lodash");var expressions=require("./expressions");var aggregation=require("./aggregation");module.exports=function(service){return{filter:filter,filterAll:filterAll,applyFilters:applyFilters,makeFunction:makeFunction,scanForDynamicFilters:scanForDynamicFilters};function filter(column,fil,isRange,replace){return getColumn(column).then(function(column){var newFilters=_.assign({},service.filters);var filterKey=column.key;if(column.complex==="array"){filterKey=JSON.stringify(column.key)}if(column.complex==="function"){filterKey=column.key.toString()}newFilters[filterKey]=buildFilterObject(fil,isRange,replace);return applyFilters(newFilters)})}function getColumn(column){var exists=service.column.find(column);return new Promise(function(resolve,reject){try{if(!exists){return resolve(service.column({key:column,temporary:true}).then(function(){return service.column.find(column)}))}else{resolve(exists)}}catch(err){reject(err)}})}function filterAll(fils){if(!fils){service.columns.forEach(function(col){col.dimension.filterAll()});return applyFilters({})}var newFilters=_.assign({},service.filters);var ds=_.map(fils,function(fil){return getColumn(fil.column).then(function(column){var filterKey=column.complex?JSON.stringify(column.key):column.key;newFilters[filterKey]=buildFilterObject(fil.value,fil.isRange,fil.replace)})});return Promise.all(ds).then(function(){return applyFilters(newFilters)})}function buildFilterObject(fil,isRange,replace){if(_.isUndefined(fil)){return false}if(_.isFunction(fil)){return{value:fil,function:fil,replace:true,type:"function"}}if(_.isObject(fil)){return{value:fil,function:makeFunction(fil),replace:true,type:"function"}}if(_.isArray(fil)){return{value:fil,replace:isRange||replace,type:isRange?"range":"inclusive"}}return{value:fil,replace:replace,type:"exact"}}function applyFilters(newFilters){var ds=_.map(newFilters,function(fil,i){var existing=service.filters[i];if(fil===existing){return Promise.resolve()}var column;if(i.charAt(0)==="["){column=service.column.find(JSON.parse(i))}else{column=service.column.find(i)}if(fil&&existing&&!fil.replace){newFilters[i]=fil=toggleFilters(fil,existing)}if(!fil){return Promise.resolve(column.dimension.filterAll())}if(fil.type==="exact"){return Promise.resolve(column.dimension.filterExact(fil.value))}if(fil.type==="range"){return Promise.resolve(column.dimension.filterRange(fil.value))}if(fil.type==="inclusive"){return Promise.resolve(column.dimension.filterFunction(function(d){return fil.value.indexOf(d)>-1}))}if(fil.type==="function"){return Promise.resolve(column.dimension.filterFunction(fil.function))}return Promise.resolve(column.dimension.filterAll())});return Promise.all(ds).then(function(){service.filters=newFilters;var tryRemoval=[];_.forEach(service.filters,function(val,key){if(!val){tryRemoval.push({key:key,val:val});delete service.filters[key]}});return Promise.all(_.map(tryRemoval,function(v){var column=service.column.find(v.key.charAt(0)==="["?JSON.parse(v.key):v.key);if(column.temporary&&!column.dynamicReference){return service.clear(column.key)}}))}).then(function(){return Promise.all(_.map(service.filterListeners,function(listener){return listener()}))}).then(function(){return service})}function toggleFilters(fil,existing){if(fil.type==="exact"&&existing.type==="inclusive"){fil.value=_.xor([fil.value],existing.value)}else if(fil.type==="inclusive"&&existing.type==="exact"){fil.value=_.xor(fil.value,[existing.value])}else if(fil.type==="inclusive"&&existing.type==="inclusive"){fil.value=_.xor(fil.value,existing.value)}else if(fil.type==="exact"&&existing.type==="exact"){if(fil.value===existing.value){return false}fil.value=[fil.value,existing.value]}if(!fil.value.length){fil=false}else if(fil.value.length===1){fil.type="exact";fil.value=fil.value[0]}else{fil.type="inclusive"}return fil}function scanForDynamicFilters(query){var columns=[];walk(query.filter);return columns;function walk(obj){_.forEach(obj,function(val,key){var ref=findDataReferences(val,key);if(ref){columns.push(ref)}if(_.isString(val)){ref=findDataReferences(null,val);if(ref){columns.push(ref)}}if(_.isObject(val)){walk(val)}})}}function findDataReferences(val,key){if(key==="$data"){return true}if(key&&key==="$column"){if(_.isString(val)){return val}console.warn('The value for filter "$column" must be a valid column key',val);return false}}function makeFunction(obj,isAggregation){var subGetters;if(_.isString(obj)){var dataRef=findDataReferences(null,obj);if(dataRef){var data=service.cf.all();return function(){return data}}}if(_.isString(obj)||_.isNumber(obj)||_.isBoolean(obj)){return function(d){if(typeof d==="undefined"){return obj}return expressions.$eq(d,function(){return obj})}}if(_.isArray(obj)){subGetters=_.map(obj,function(o){return makeFunction(o,isAggregation)});return function(d){return subGetters.map(function(s){return s(d)})}}if(_.isObject(obj)){subGetters=_.map(obj,function(val,key){var getSub=makeFunction(val,isAggregation);var dataRef=findDataReferences(val,key);if(dataRef){var column=service.column.find(dataRef);var data=column.values;return function(){return data}}if(expressions[key]){return function(d){return expressions[key](d,getSub)}}var aggregatorObj=aggregation.parseAggregatorParams(key);if(aggregatorObj){isAggregation=true;getSub=makeFunction(val,isAggregation);return function(){return aggregatorObj.aggregator.apply(null,[getSub()].concat(aggregatorObj.params))}}return function(d){d=d[key];return getSub(d,getSub)}});if(isAggregation){if(subGetters.length===1){return function(d){return subGetters[0](d)}}return function(d){return _.map(subGetters,function(getSub){return getSub(d)})}}return function(d){return expressions.$and(d,function(d){return _.map(subGetters,function(getSub){return getSub(d)})})}}console.log("no expression found for ",obj);return false}}},{"./aggregation":44,"./expressions":50,"./lodash":52}],52:[function(require,module,exports){"use strict";module.exports={assign:assign,find:find,remove:remove,isArray:isArray,isObject:isObject,isBoolean:isBoolean,isString:isString,isNumber:isNumber,isFunction:isFunction,get:get,set:set,map:map,keys:keys,sortBy:sortBy,forEach:forEach,isUndefined:isUndefined,pick:pick,xor:xor,clone:clone,isEqual:isEqual,replaceArray:replaceArray,uniq:uniq,flatten:flatten,sort:sort,values:values,recurseObject:recurseObject};function assign(out){out=out||{};for(var i=1;i1){var e=prop.shift();assign(obj[e]=Object.prototype.toString.call(obj[e])==="[object Object]"?obj[e]:{},prop,value)}else{obj[prop[0]]=value}}function map(a,b){var m;var key;if(isFunction(b)){if(isObject(a)){m=[];for(key in a){if(a.hasOwnProperty(key)){m.push(b(a[key],key,a))}}return m}return a.map(b)}if(isObject(a)){m=[];for(key in a){if(a.hasOwnProperty(key)){m.push(a[key])}}return m}return a.map(function(aa){return aa[b]})}function keys(obj){return Object.keys(obj)}function sortBy(a,b){if(isFunction(b)){return a.sort(function(aa,bb){if(b(aa)>b(bb)){return 1}if(b(aa)bl){a.splice(bl,al-bl)}else if(altmp){arr[j]=arr[j-1];--j}arr[j]=tmp}return arr}function values(a){var values=[];for(var key in a){if(a.hasOwnProperty(key)){values.push(a[key])}}return values}function recurseObject(obj,cb){_recurseObject(obj,[]);return obj;function _recurseObject(obj,path){for(var k in obj){var newPath=clone(path);newPath.push(k);if(typeof obj[k]==="object"&&obj[k]!==null){_recurseObject(obj[k],newPath)}else{if(!obj.hasOwnProperty(k)){continue}cb(obj[k],k,newPath)}}}}},{}],53:[function(require,module,exports){"use strict";var _=require("./lodash");var aggregation=require("./aggregation");module.exports=function(){return{post:post,sortByKey:sortByKey,limit:limit,squash:squash,change:change,changeMap:changeMap};function post(query,parent,cb){query.data=cloneIfLocked(parent);return Promise.resolve(cb(query,parent))}function sortByKey(query,parent,desc){query.data=cloneIfLocked(parent);query.data=_.sortBy(query.data,function(d){return d.key});if(desc){query.data.reverse()}}function limit(query,parent,start,end){query.data=cloneIfLocked(parent);if(_.isUndefined(end)){end=start||0;start=0}else{start=start||0;end=end||query.data.length}query.data=query.data.splice(start,end-start)}function squash(query,parent,start,end,aggObj,label){query.data=cloneIfLocked(parent);start=start||0;end=end||query.data.length;var toSquash=query.data.splice(start,end-start);var squashed={key:label||"Other",value:{}};_.recurseObject(aggObj,function(val,key,path){var items=[];_.forEach(toSquash,function(record){items.push(_.get(record.value,path))});_.set(squashed.value,path,aggregation.aggregators[val](items))});query.data.splice(start,0,squashed)}function change(query,parent,start,end,aggObj){query.data=cloneIfLocked(parent);start=start||0;end=end||query.data.length;var obj={key:[query.data[start].key,query.data[end].key],value:{}};_.recurseObject(aggObj,function(val,key,path){var changePath=_.clone(path);changePath.pop();changePath.push(key+"Change");_.set(obj.value,changePath,_.get(query.data[end].value,path)-_.get(query.data[start].value,path))});query.data=obj}function changeMap(query,parent,aggObj,defaultNull){defaultNull=_.isUndefined(defaultNull)?0:defaultNull;query.data=cloneIfLocked(parent);_.recurseObject(aggObj,function(val,key,path){var changePath=_.clone(path);var fromStartPath=_.clone(path);var fromEndPath=_.clone(path);changePath.pop();fromStartPath.pop();fromEndPath.pop();changePath.push(key+"Change");fromStartPath.push(key+"ChangeFromStart");fromEndPath.push(key+"ChangeFromEnd");var start=_.get(query.data[0].value,path,defaultNull);var end=_.get(query.data[query.data.length-1].value,path,defaultNull);_.forEach(query.data,function(record,i){var previous=query.data[i-1]||query.data[0];_.set(query.data[i].value,changePath,_.get(record.value,path,defaultNull)-(previous?_.get(previous.value,path,defaultNull):defaultNull));_.set(query.data[i].value,fromStartPath,_.get(record.value,path,defaultNull)-start);_.set(query.data[i].value,fromEndPath,_.get(record.value,path,defaultNull)-end)})})}};function cloneIfLocked(parent){return parent.locked?_.clone(parent.data):parent.data}},{"./aggregation":44,"./lodash":52}],54:[function(require,module,exports){"use strict";var _=require("./lodash");module.exports=function(service){var reductiofy=require("./reductiofy")(service);var filters=require("./filters")(service);var postAggregation=require("./postAggregation")(service);var postAggregationMethods=_.keys(postAggregation);return function doQuery(queryObj){var queryHash=JSON.stringify(queryObj);for(var i=0;i1){query.locked=true}return Promise.all(_.map(query.postAggregations,function(post){return post()})).then(function(){return query})}function newQueryObj(q,parent){var locked=false;if(!parent){parent=q;q={};locked=true}_.assign(q,{universe:service,crossfilter:service.cf,parent:parent,column:parent.column,dimension:parent.dimension,group:parent.group,reducer:parent.reducer,original:parent.original,hash:parent.hash,removeListeners:[],postAggregations:[],locked:locked,lock:lock,unlock:unlock,clear:clearQuery});_.forEach(postAggregationMethods,function(method){q[method]=postAggregateMethodWrap(postAggregation[method])});return q;function lock(set){if(!_.isUndefined(set)){q.locked=Boolean(set);return}q.locked=true}function unlock(){q.locked=false}function clearQuery(){_.forEach(q.removeListeners,function(l){l()});return new Promise(function(resolve,reject){try{resolve(q.group.dispose())}catch(err){reject(err)}}).then(function(){q.column.queries.splice(q.column.queries.indexOf(q),1);if(!q.column.queries.length){return service.clear(q.column.key)}}).then(function(){return service})}function postAggregateMethodWrap(postMethod){return function(){var args=Array.prototype.slice.call(arguments);var sub={};newQueryObj(sub,q);args.unshift(sub,q);q.postAggregations.push(function(){Promise.resolve(postMethod.apply(null,args)).then(postAggregateChildren)});return Promise.resolve(postMethod.apply(null,args)).then(postAggregateChildren);function postAggregateChildren(){return postAggregate(sub).then(function(){return sub})}}}}}}},{"./filters":51,"./lodash":52,"./postAggregation":53,"./reductiofy":56}],55:[function(require,module,exports){"use strict";module.exports={shorthandLabels:{$count:"count",$sum:"sum",$avg:"avg",$min:"min",$max:"max",$med:"med",$sumSq:"sumSq",$std:"std"},aggregators:{$count:$count,$sum:$sum,$avg:$avg,$min:$min,$max:$max,$med:$med,$sumSq:$sumSq,$std:$std,$valueList:$valueList,$dataList:$dataList}};function $count(reducer){return reducer.count(true)}function $sum(reducer,value){return reducer.sum(value)}function $avg(reducer,value){return reducer.avg(value)}function $min(reducer,value){return reducer.min(value)}function $max(reducer,value){return reducer.max(value)}function $med(reducer,value){return reducer.median(value)}function $sumSq(reducer,value){return reducer.sumOfSq(value)}function $std(reducer,value){return reducer.std(value)}function $valueList(reducer,value){return reducer.valueList(value)}function $dataList(reducer){return reducer.dataList(true)}},{}],56:[function(require,module,exports){"use strict";var reductio=require("reductio");var _=require("./lodash");var rAggregators=require("./reductioAggregators");var aggregation=require("./aggregation");module.exports=function(service){var filters=require("./filters")(service);return function reductiofy(query){var reducer=reductio();aggregateOrNest(reducer,query.select);if(query.filter){var filterFunction=filters.makeFunction(query.filter);if(filterFunction){reducer.filter(filterFunction)}}return Promise.resolve(reducer);function aggregateOrNest(reducer,selects){var sortedSelectKeyValue=_.sortBy(_.map(selects,function(val,key){return{key:key,value:val}}),function(s){if(rAggregators.aggregators[s.key]){return 0}return 1});return _.forEach(sortedSelectKeyValue,function(s){if(rAggregators.aggregators[s.key]){var accessor=aggregation.makeValueAccessor(s.value);reducer=rAggregators.aggregators[s.key](reducer,accessor);return}if(!_.isObject(s.value)){console.error("Nested selects must be an object",s.key);return}aggregateOrNest(reducer.value(s.key),s.value)})}}}},{"./aggregation":44,"./filters":51,"./lodash":52,"./reductioAggregators":55,reductio:37}],57:[function(require,module,exports){"use strict";var _=require("./lodash");module.exports=universe;function universe(data,options){var service={options:_.assign({},options),columns:[],filters:{},dataListeners:[],filterListeners:[]};var cf=require("./crossfilter")(service);var filters=require("./filters")(service);data=cf.generateColumns(data);return cf.build(data).then(function(data){service.cf=data;return _.assign(service,{add:cf.add,remove:cf.remove,column:require("./column")(service),query:require("./query")(service),filter:filters.filter,filterAll:filters.filterAll,applyFilters:filters.applyFilters,clear:require("./clear")(service),destroy:require("./destroy")(service),onDataChange:onDataChange,onFilter:onFilter})});function onDataChange(cb){service.dataListeners.push(cb);return function(){service.dataListeners.splice(service.dataListeners.indexOf(cb),1)}}function onFilter(cb){service.filterListeners.push(cb);return function(){service.filterListeners.splice(service.filterListeners.indexOf(cb),1)}}}},{"./clear":45,"./column":46,"./crossfilter":47,"./destroy":48,"./filters":51,"./lodash":52,"./query":54}]},{},[57])(57)}); \ No newline at end of file