Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
{"version":3,"sources":["webpack:///./node_modules/crossfilter/index.js","webpack:///./node_modules/crossfilter/crossfilter.js"],"names":["module","exports","crossfilter","crossfilter_identity","d","permute","array","index","i","n","length","copy","Array","version","bisect","bisect_by","f","bisectRight","a","x","lo","hi","mid","right","left","heap_by","heap","sift","child","sort","t","heapselect_by","k","min","queue","Math","insertionsort_by","j","quicksort_by","insertionsort","quicksort_sizeThreshold","quicksort","sixth","i1","i5","i3","i2","i4","e1","x1","e2","x2","e3","x3","e4","x4","e5","x5","pivot1","pivotValue1","pivot2","pivotValue2","less","great","pivotsEqual","ek","xk","greatValue","lessValue","by","heapselect","crossfilter_array8","crossfilter_arrayUntyped","crossfilter_array16","crossfilter_array32","crossfilter_arrayLengthen","crossfilter_arrayWiden","width","Error","crossfilter_filterExact","value","values","crossfilter_filterRange","range","max","crossfilter_filterAll","crossfilter_null","crossfilter_zero","crossfilter_reduceIncrement","p","crossfilter_reduceDecrement","crossfilter_reduceAdd","v","crossfilter_reduceSubtract","add","remove","removeData","dimension","groupAll","size","data","m","M","filters","filterListeners","dataListeners","removeDataListeners","newData","n0","n1","concat","forEach","l","newIndex","crossfilter_index","removed","push","newValues","refilterFunction","filter","filterAll","isArray","filterRange","filterFunction","filterExact","top","hi0","lo0","bottom","group","g","all","order","orderNatural","dispose","one","zero","refilter","indexListeners","dimensionGroups","preAdd","map","crossfilter_range","bounds","lo1","hi1","oldValues","oldIndex","i0","postAdd","reIndex","filterIndexBounds","filterIndexFunction","added","key","reduce","reduceCount","reduceSum","groups","groupIndex","select","reduceAdd","reduceRemove","reduceInitial","groupWidth","groupCapacity","crossfilter_capacity","update","reset","resetNeeded","g0","x0","oldGroups","initial","k0","groupIncrement","indexOf","updateMany","resetMany","updateOne","resetOne","oldK","seenGroups","filterOne","valueOf","splice","arguments","unshift","reduceValue","w","Uint8Array","Uint16Array","Uint32Array","constructor","set","this"],"mappings":"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","file":"57e33c6c-23.11b9f72925818240e61d.js","sourcesContent":["module.exports = require(\"./crossfilter\").crossfilter;\n","(function(exports){\ncrossfilter.version = \"1.3.12\";\nfunction crossfilter_identity(d) {\n return d;\n}\ncrossfilter.permute = permute;\n\nfunction permute(array, index) {\n for (var i = 0, n = index.length, copy = new Array(n); i < n; ++i) {\n copy[i] = array[index[i]];\n }\n return copy;\n}\nvar bisect = crossfilter.bisect = bisect_by(crossfilter_identity);\n\nbisect.by = bisect_by;\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}\nvar heap = crossfilter.heap = heap_by(crossfilter_identity);\n\nheap.by = heap_by;\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}\nvar heapselect = crossfilter.heapselect = heapselect_by(crossfilter_identity);\n\nheapselect.by = heapselect_by;\n\nfunction heapselect_by(f) {\n var heap = heap_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 x,\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 (x = 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}\nvar insertionsort = crossfilter.insertionsort = insertionsort_by(crossfilter_identity);\n\ninsertionsort.by = insertionsort_by;\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// Algorithm designed by Vladimir Yaroslavskiy.\n// Implementation based on the Dart project; see lib/dart/LICENSE for details.\n\nvar quicksort = crossfilter.quicksort = quicksort_by(crossfilter_identity);\n\nquicksort.by = quicksort_by;\n\nfunction quicksort_by(f) {\n var insertionsort = insertionsort_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 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 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 }\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 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 while (true) {\n var 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 }\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;\nvar crossfilter_array8 = crossfilter_arrayUntyped,\n crossfilter_array16 = crossfilter_arrayUntyped,\n crossfilter_array32 = crossfilter_arrayUntyped,\n crossfilter_arrayLengthen = crossfilter_arrayLengthenUntyped,\n crossfilter_arrayWiden = crossfilter_arrayWidenUntyped;\n\nif (typeof Uint8Array !== \"undefined\") {\n crossfilter_array8 = function(n) { return new Uint8Array(n); };\n crossfilter_array16 = function(n) { return new Uint16Array(n); };\n crossfilter_array32 = function(n) { return new Uint32Array(n); };\n\n 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 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}\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}\nfunction crossfilter_null() {\n return null;\n}\nfunction crossfilter_zero() {\n return 0;\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}\nexports.crossfilter = crossfilter;\n\nfunction crossfilter() {\n var crossfilter = {\n add: add,\n remove: removeData,\n dimension: dimension,\n groupAll: groupAll,\n size: size\n };\n\n var data = [], // the records\n n = 0, // the number of records; data.length\n m = 0, // a bit mask representing which dimensions are in use\n M = 8, // number of dimensions that can fit in `filters`\n filters = crossfilter_array8(0), // M bits per record; 1 is filtered out\n filterListeners = [], // when the filters change\n dataListeners = [], // when data is added\n removeDataListeners = []; // when data is removed\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 = crossfilter_arrayLengthen(filters, n += n1);\n dataListeners.forEach(function(l) { l(newData, n0, n1); });\n }\n\n return crossfilter;\n }\n\n // Removes all records that match the current filters.\n function removeData() {\n var newIndex = crossfilter_index(n, n),\n removed = [];\n for (var i = 0, j = 0; i < n; ++i) {\n if (filters[i]) newIndex[i] = j++;\n else removed.push(i);\n }\n\n // Remove all matching records from groups.\n filterListeners.forEach(function(l) { l(0, [], removed); });\n\n // Update indexes.\n removeDataListeners.forEach(function(l) { l(newIndex); });\n\n // Remove old filters and data by overwriting.\n for (var i = 0, j = 0, k; i < n; ++i) {\n if (k = filters[i]) {\n if (i !== j) filters[j] = k, data[j] = data[i];\n ++j;\n }\n }\n data.length = j;\n while (n > j) filters[--n] = 0;\n }\n\n // Adds a new dimension with the specified value accessor function.\n function dimension(value) {\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 };\n\n var one = ~m & -~m, // lowest unset bit as mask, e.g., 00001000\n zero = ~one, // inverted one, e.g., 11110111\n values, // sorted, cached array\n index, // value rank ↦ object id\n newValues, // temporary array storing newly-added values\n newIndex, // temporary array storing newly-added index\n sort = quicksort_by(function(i) { return newValues[i]; }),\n refilter = crossfilter_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\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 // Incorporate any existing data into this dimension, and make sure that the\n // filter bitset is wide enough to handle the new dimension.\n m |= one;\n if (M >= 32 ? !one : m & -(1 << M)) {\n filters = crossfilter_arrayWiden(filters, M <<= 1);\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 // Permute new values into natural order using a sorted index.\n newValues = newData.map(value);\n newIndex = sort(crossfilter_range(n1), 0, n1);\n newValues = permute(newValues, newIndex);\n\n // Bisect newValues to determine which new records are selected.\n var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1], i;\n if (refilterFunction) {\n for (i = 0; i < n1; ++i) {\n if (!refilterFunction(newValues[i], i)) filters[newIndex[i] + n0] |= one;\n }\n } else {\n for (i = 0; i < lo1; ++i) filters[newIndex[i] + n0] |= one;\n for (i = hi1; i < n1; ++i) filters[newIndex[i] + n0] |= one;\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 lo0 = lo1;\n hi0 = hi1;\n return;\n }\n\n var oldValues = values,\n oldIndex = index,\n i0 = 0,\n i1 = 0;\n\n // Otherwise, create new arrays into which to merge new and old.\n values = new Array(n);\n index = crossfilter_index(n, n);\n\n // Merge the old and new sorted values, and old and new index.\n for (i = 0; i0 < n0 && i1 < n1; ++i) {\n if (oldValues[i0] < newValues[i1]) {\n values[i] = oldValues[i0];\n index[i] = oldIndex[i0++];\n } else {\n values[i] = newValues[i1];\n index[i] = newIndex[i1++] + n0;\n }\n }\n\n // Add any remaining old values.\n for (; i0 < n0; ++i0, ++i) {\n values[i] = oldValues[i0];\n index[i] = oldIndex[i0];\n }\n\n // Add any remaining new values.\n for (; i1 < n1; ++i1, ++i) {\n values[i] = newValues[i1];\n index[i] = newIndex[i1] + 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 for (var i = 0, j = 0, k; i < n; ++i) {\n if (filters[k = index[i]]) {\n if (i !== j) values[j] = values[i];\n index[j] = reIndex[k];\n ++j;\n }\n }\n values.length = j;\n while (j < n) 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 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; });\n lo0 = lo1;\n hi0 = hi1;\n return dimension;\n }\n\n var i,\n j,\n k,\n added = [],\n removed = [];\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 filters[k = index[i]] ^= one;\n added.push(k);\n }\n } else if (lo1 > lo0) {\n for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) {\n filters[k = index[i]] ^= one;\n removed.push(k);\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 filters[k = index[i]] ^= one;\n added.push(k);\n }\n } else if (hi1 < hi0) {\n for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) {\n filters[k = index[i]] ^= one;\n removed.push(k);\n }\n }\n\n lo0 = lo1;\n hi0 = hi1;\n filterListeners.forEach(function(l) { l(one, added, removed); });\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 = crossfilter_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 = crossfilter_filterRange(bisect, range))(values));\n }\n\n // Clears any filters on this dimension.\n function filterAll() {\n return filterIndexBounds((refilter = crossfilter_filterAll)(values));\n }\n\n // Filters this dimension using an arbitrary function.\n function filterFunction(f) {\n refilter = crossfilter_filterAll;\n\n filterIndexFunction(refilterFunction = f);\n\n lo0 = 0;\n hi0 = n;\n\n return dimension;\n }\n\n function filterIndexFunction(f) {\n var i,\n k,\n x,\n added = [],\n removed = [];\n\n for (i = 0; i < n; ++i) {\n if (!(filters[k = index[i]] & one) ^ !!(x = f(values[i], i))) {\n if (x) filters[k] &= zero, added.push(k);\n else filters[k] |= one, removed.push(k);\n }\n }\n filterListeners.forEach(function(l) { l(one, added, removed); });\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) {\n var array = [],\n i = hi0,\n j;\n\n while (--i >= lo0 && k > 0) {\n if (!filters[j = index[i]]) {\n array.push(data[j]);\n --k;\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) {\n var array = [],\n i = lo0,\n j;\n\n while (i < hi0 && k > 0) {\n if (!filters[j = index[i]]) {\n array.push(data[j]);\n --k;\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\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 var oldGroups = groups,\n reIndex = crossfilter_index(k, groupCapacity),\n add = reduceAdd,\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\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 groupIndex = k0 > 1 ? crossfilter_arrayLengthen(groupIndex, n) : crossfilter_index(n, groupCapacity);\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 if (g0 = oldGroups[++i0]) 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 while (!(x1 > x)) {\n groupIndex[j = newIndex[i1] + n0] = k;\n if (!(filters[j] & zero)) g.value = add(g.value, data[j]);\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 than 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 // If we added any new groups before any old groups,\n // update the group index of all the old records.\n if (k > i0) for (i0 = 0; i0 < n0; ++i0) {\n groupIndex[i0] = reIndex[groupIndex[i0]];\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) {\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 (++k === groupCapacity) {\n reIndex = crossfilter_arrayWiden(reIndex, groupWidth <<= 1);\n groupIndex = crossfilter_arrayWiden(groupIndex, groupWidth);\n groupCapacity = crossfilter_capacity(groupWidth);\n }\n }\n }\n\n function removeData() {\n if (k > 1) {\n var oldK = k,\n oldGroups = groups,\n seenGroups = crossfilter_index(oldK, oldK);\n\n // Filter out non-matches by copying matching group index entries to\n // the beginning of the array.\n for (var i = 0, j = 0; i < n; ++i) {\n if (filters[i]) {\n seenGroups[groupIndex[j] = groupIndex[i]] = 1;\n ++j;\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) {\n // Reindex the group index using seenGroups to find the new index.\n for (var i = 0; i < j; ++i) groupIndex[i] = seenGroups[groupIndex[i]];\n } else {\n groupIndex = null;\n }\n filterListeners[filterListeners.indexOf(update)] = k > 1\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 i = 0; i < n; ++i) if (filters[i]) 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 function updateMany(filterOne, added, removed) {\n if (filterOne === one || resetNeeded) return;\n\n var i,\n k,\n n,\n g;\n\n // Add the added values.\n for (i = 0, n = added.length; i < n; ++i) {\n if (!(filters[k = added[i]] & zero)) {\n g = groups[groupIndex[k]];\n g.value = reduceAdd(g.value, data[k]);\n }\n }\n\n // Remove the removed values.\n for (i = 0, n = removed.length; i < n; ++i) {\n if ((filters[k = removed[i]] & zero) === filterOne) {\n g = groups[groupIndex[k]];\n g.value = reduceRemove(g.value, data[k]);\n }\n }\n }\n\n // Reduces the specified selected or deselected records.\n // This function is only used when the cardinality is 1.\n function updateOne(filterOne, added, removed) {\n if (filterOne === one || 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[k = added[i]] & zero)) {\n g.value = reduceAdd(g.value, data[k]);\n }\n }\n\n // Remove the removed values.\n for (i = 0, n = removed.length; i < n; ++i) {\n if ((filters[k = removed[i]] & zero) === filterOne) {\n g.value = reduceRemove(g.value, data[k]);\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 g;\n\n // Reset all group values.\n for (i = 0; i < k; ++i) {\n groups[i].value = reduceInitial();\n }\n\n // Add any selected records.\n for (i = 0; i < n; ++i) {\n if (!(filters[i] & zero)) {\n g = groups[groupIndex[i]];\n g.value = reduceAdd(g.value, data[i]);\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 // Add any selected records.\n for (i = 0; i < n; ++i) {\n if (!(filters[i] & zero)) {\n g.value = reduceAdd(g.value, data[i]);\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(crossfilter_reduceIncrement, crossfilter_reduceDecrement, crossfilter_zero);\n }\n\n // A convenience method for reducing by sum(value).\n function reduceSum(value) {\n return reduce(crossfilter_reduceAdd(value), crossfilter_reduceSubtract(value), crossfilter_zero);\n }\n\n // Sets the reduce order, using the specified accessor.\n function order(value) {\n select = heapselect_by(valueOf);\n heap = heap_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 m &= 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 // Add the added values.\n for (i = n0; i < n; ++i) {\n if (!filters[i]) {\n reduceValue = reduceAdd(reduceValue, data[i]);\n }\n }\n }\n\n // Reduces the specified selected or deselected records.\n function update(filterOne, added, removed) {\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[k = added[i]]) {\n reduceValue = reduceAdd(reduceValue, data[k]);\n }\n }\n\n // Remove the removed values.\n for (i = 0, n = removed.length; i < n; ++i) {\n if (filters[k = removed[i]] === filterOne) {\n reduceValue = reduceRemove(reduceValue, data[k]);\n }\n }\n }\n\n // Recomputes the group reduce value from scratch.\n function reset() {\n var i;\n\n reduceValue = reduceInitial();\n\n for (i = 0; i < n; ++i) {\n if (!filters[i]) {\n reduceValue = reduceAdd(reduceValue, data[i]);\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(crossfilter_reduceIncrement, crossfilter_reduceDecrement, crossfilter_zero);\n }\n\n // A convenience method for reducing by sum(value).\n function reduceSum(value) {\n return reduce(crossfilter_reduceAdd(value), crossfilter_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);\n i = dataListeners.indexOf(add);\n if (i >= 0) dataListeners.splice(i);\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 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 ? crossfilter_array8 : m < 0x10001\n ? crossfilter_array16\n : crossfilter_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})(typeof exports !== 'undefined' && exports || this);\n"],"sourceRoot":""}
