crossfilter.js

// https://github.com/smartdataHQ/crossfilter v3.0.2 Copyright 2026 Mike Bostock
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.crossfilter = factory());
})(this, (function () { 'use strict';

  let array8 = arrayUntyped,
      array16 = arrayUntyped,
      array32 = arrayUntyped,
      arrayLengthen = arrayLengthenUntyped,
      arrayWiden = arrayWidenUntyped;
  if (typeof Uint8Array !== "undefined") {
    array8 = function(n) { return new Uint8Array(n); };
    array16 = function(n) { return new Uint16Array(n); };
    array32 = function(n) { return new Uint32Array(n); };

    arrayLengthen = function(array, length) {
      if (array.length >= length) return array;
      var copy = new array.constructor(length);
      copy.set(array);
      return copy;
    };

    arrayWiden = function(array, width) {
      var copy;
      switch (width) {
        case 16: copy = array16(array.length); break;
        case 32: copy = array32(array.length); break;
        default: throw new Error("invalid array width!");
      }
      copy.set(array);
      return copy;
    };
  }

  function arrayUntyped(n) {
    var array = new Array(n), i = -1;
    while (++i < n) array[i] = 0;
    return array;
  }

  function arrayLengthenUntyped(array, length) {
    var n = array.length;
    while (n < length) array[n++] = 0;
    return array;
  }

  function arrayWidenUntyped(array, width) {
    if (width > 32) throw new Error("invalid array width!");
    return array;
  }

  // An arbitrarily-wide array of bitmasks
  function bitarray(n) {
    this.length = n;
    this.subarrays = 1;
    this.width = 8;
    this.masks = {
      0: 0
    };

    this[0] = array8(n);
  }

  bitarray.prototype.lengthen = function(n) {
    var i, len;
    for (i = 0, len = this.subarrays; i < len; ++i) {
      this[i] = arrayLengthen(this[i], n);
    }
    this.length = n;
  };

  // Reserve a new bit index in the array, returns {offset, one}
  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);
      // isolate the rightmost zero bit and return it as an unsigned int of 32 bits, if NaN or -1, return a 0 
      one = (~m & (m + 1)) >>> 0;

      if (w >= 32 && !one) {
        continue;
      }

      if (w < 32 && (one & (1 << w))) {
        // widen this subarray
        this[i] = 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] = 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
  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
  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.length = n;
  };

  // Checks that all bits for the given index are 0
  bitarray.prototype.zero = function(n) {
    if (this.subarrays === 1) {
      return !this[0][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
  bitarray.prototype.zeroExcept = function(n, offset, zero) {
    if (this.subarrays === 1) {
      var mask = this[0][n];
      return !(offset === 0 ? mask & zero : mask);
    }
    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 index are 0 except for the specified mask.
  // The mask should be an array of the same size as the filter subarrays width.
  bitarray.prototype.zeroExceptMask = function(n, mask) {
    if (this.subarrays === 1) {
      return !(this[0][n] & mask[0]);
    }
    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
  bitarray.prototype.only = function(n, offset, one) {
    if (this.subarrays === 1) {
      return this[0][n] === (offset === 0 ? one : 0);
    }
    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
  bitarray.prototype.onlyExcept = function(n, offset, zero, onlyOffset, onlyOne) {
    if (this.subarrays === 1) {
      var masked = this[0][n];
      if (offset === 0) {
        masked = (masked & zero) >>> 0;
      }
      return masked === (onlyOffset === 0 ? onlyOne : 0);
    }
    var mask;
    var i, len;
    for (i = 0, len = this.subarrays; i < len; ++i) {
      mask = this[i][n];
      if (i === offset)
        mask = (mask & zero) >>> 0;
      if (mask != (i === onlyOffset ? onlyOne : 0)) {
        return false;
      }
    }
    return true;
  };

  var xfilterArray = {
    array8: array8,
    array16: array16,
    array32: array32,
    arrayLengthen: arrayLengthen,
    arrayWiden: arrayWiden,
    bitarray: bitarray
  };

  const filterExact = (bisect, value) => {
    return function(values) {
      var n = values.length;
      return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)];
    };
  };

  const 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)];
    };
  };

  const filterAll = values => {
    return [0, values.length];
  };

  var xfilterFilter = {
    filterExact,
    filterRange,
    filterAll
  };

  var cr_identity = d => {
    return d;
  };

  var cr_null = () =>  {
    return null;
  };

  var cr_zero = () => {
    return 0;
  };

  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;
  }

  const h$1 = heap_by(cr_identity);
  h$1.by = heap_by;

  function heapselect_by(f) {
    var heap = h$1.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;
  }


  const h = heapselect_by(cr_identity);
  h.by = heapselect_by; // assign the raw function to the export as well

  function primitiveValue(value) {
    if (value == null || typeof value !== 'object') {
      return value;
    }

    if (typeof value.valueOf === 'function') {
      var primitive = value.valueOf();
      if (primitive !== value) {
        return primitive;
      }
    }

    if (typeof value.toString === 'function') {
      var text = value.toString();
      if (text !== value) {
        return text;
      }
    }

    return value;
  }

  function typeRank(value) {
    if (value === null) {
      return 0;
    }

    switch (typeof value) {
      case 'boolean':
        return 1;
      case 'number':
        return 2;
      case 'bigint':
        return 3;
      case 'string':
        return 4;
      case 'symbol':
        return 5;
      case 'undefined':
        return 6;
      default:
        return 7;
    }
  }

  function equivalentByNaturalCoercion(left, right) {
    if (typeof left === 'symbol' || typeof right === 'symbol') {
      return false;
    }

    var numericLeft = Number(left),
        numericRight = Number(right);

    return numericLeft === numericRight && numericLeft === numericLeft;
  }

  function compareNaturalOrder(left, right) {
    var a = primitiveValue(left),
        b = primitiveValue(right),
        rankA,
        rankB,
        descA,
        descB,
        textA,
        textB;

    if (Object.is(a, b) || a === b) {
      return 0;
    }

    if (typeof a !== 'symbol' && typeof b !== 'symbol') {
      if (a < b) {
        return -1;
      }
      if (a > b) {
        return 1;
      }
      if (equivalentByNaturalCoercion(a, b)) {
        return 0;
      }
    }

    rankA = typeRank(a);
    rankB = typeRank(b);

    if (rankA !== rankB) {
      return rankA - rankB;
    }

    if (rankA === 5) {
      descA = a.description;
      descB = b.description;
      if (descA === descB) {
        return 0;
      }
      if (descA == null) {
        return -1;
      }
      if (descB == null) {
        return 1;
      }
      return descA < descB ? -1 : 1;
    }

    textA = String(a);
    textB = String(b);
    if (textA < textB) {
      return -1;
    }
    if (textA > textB) {
      return 1;
    }

    return 0;
  }

  function isNaturallyOrderable(value) {
    var normalized = primitiveValue(value);

    if (normalized === null) {
      return true;
    }
    if (normalized === undefined) {
      return false;
    }
    if (typeof normalized === 'number') {
      return normalized === normalized;
    }

    return true;
  }

  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 (compareNaturalOrder(f(a[mid]), x) < 0) 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 (compareNaturalOrder(x, f(a[mid])) < 0) hi = mid;
        else lo = mid + 1;
      }
      return lo;
    }

    bisectRight.right = bisectRight;
    bisectRight.left = bisectLeft;
    return bisectRight;
  }

  const bisect = bisect_by(cr_identity);
  bisect.by = bisect_by; // assign the raw function to the export as well

  var 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;
  };

  const reduceIncrement = p => {
    return p + 1;
  };

  const reduceDecrement = p => {
    return p - 1;
  };

  const reduceAdd = f => {
    return function(p, v) {
      return p + +f(v);
    };
  };

  const reduceSubtract = f => {
    return function(p, v) {
      return p - f(v);
    };
  };

  var xfilterReduce = {
    reduceIncrement,
    reduceDecrement,
    reduceAdd,
    reduceSubtract
  };

  function deep(t,e,i,n,r){for(r in n=(i=i.split(".")).splice(-1,1),i)e=e[i[r]]=e[i[r]]||{};return t(e,n)}

  // Note(cg): result was previsouly using lodash.result, not ESM compatible.
   
  const get = (obj, prop) => {
    const value = obj[prop];
    return (typeof value === 'function') ? value.call(obj) : value;
  };

  /**
   * get value of object at a deep path.
   * if the resolved value is a function,
   * it's invoked with the `this` binding of 
   * its parent object and its result is returned. 
   *  
   * @param  {Object} obj  the object (e.g. { 'a': [{ 'b': { 'c1': 3, 'c2': 4} }], 'd': {e:1} }; )
   * @param  {String} path deep path (e.g. `d.e`` or `a[0].b.c1`. Dot notation (a.0.b)is also supported)
   * @return {Any}      the resolved value
   */
  const reg = /\[([\w\d]+)\]/g;
  var result = (obj, path) => {
    return deep(get, obj, path.replace(reg, '.$1'))
  };

  const COLUMNAR_BATCH_KEY = typeof Symbol !== "undefined"
    ? Symbol.for("crossfilter3.columnarBatch")
    : "__crossfilter3ColumnarBatch__";

  function isArrayIndex(prop) {
    if (typeof prop === "symbol") {
      return false;
    }
    var index = Number(prop);
    return String(index) === prop && index >= 0 && Number.isInteger(index);
  }

  function getColumnAccessor(column) {
    if (column == null) {
      return function() { return undefined; };
    }
    if (typeof column.get === "function") {
      return function(index) { return column.get(index); };
    }
    if (typeof column.at === "function") {
      return function(index) { return column.at(index); };
    }
    return function(index) { return column[index]; };
  }

  function getColumnValue(column, index) {
    if (column == null) {
      return undefined;
    }
    if (typeof column.get === "function") {
      return column.get(index);
    }
    if (typeof column.at === "function") {
      return column.at(index);
    }
    return column[index];
  }

  function getColumnLength(column) {
    if (column == null) {
      return undefined;
    }
    if (typeof column.length === "number") {
      return column.length;
    }
    if (typeof column.size === "number") {
      return column.size;
    }
    return undefined;
  }

  function inferFields(columns, fields) {
    if (fields && fields.length) {
      return fields.slice();
    }
    return Object.keys(columns);
  }

  function inferLength(columns, fields, explicitLength) {
    if (typeof explicitLength === "number") {
      return explicitLength;
    }

    for (var i = 0; i < fields.length; ++i) {
      var columnLength = getColumnLength(columns[fields[i]]);
      if (typeof columnLength === "number") {
        return columnLength;
      }
    }

    return 0;
  }

  function maybeTransformColumns(columns, fields, length, transforms) {
    if (!transforms) {
      return columns;
    }

    var transformed = Object.assign({}, columns);
    for (var i = 0; i < fields.length; ++i) {
      var field = fields[i];
      var transform = transforms[field];
      if (typeof transform !== "function") {
        continue;
      }
      var values = new Array(length);
      for (var rowIndex = 0; rowIndex < length; ++rowIndex) {
        values[rowIndex] = transform(getColumnValue(columns[field], rowIndex), rowIndex);
      }
      transformed[field] = values;
    }

    return transformed;
  }

  function getColumnarBatch(records) {
    return records && records[COLUMNAR_BATCH_KEY]
      ? records[COLUMNAR_BATCH_KEY]
      : null;
  }

  function materializeColumnarRow(batch, index) {
    if (batch.materialized[index]) {
      return batch.rows[index];
    }

    var row;
    if (typeof batch.rowFactory === "function") {
      row = batch.rowFactory(index, batch.columns, batch.fields, batch.accessors);
    } else {
      row = {};
      for (var fieldIndex = 0; fieldIndex < batch.fields.length; ++fieldIndex) {
        row[batch.fields[fieldIndex]] = batch.accessors[fieldIndex](index);
      }
    }

    batch.rows[index] = row;
    batch.materialized[index] = 1;
    return row;
  }

  function createDefaultRowFactory(fields, accessors) {
    var fieldCount = fields.length;

    return function(index) {
      var row = {},
          fieldIndex = 0;

      for (; fieldIndex + 3 < fieldCount; fieldIndex += 4) {
        row[fields[fieldIndex]] = accessors[fieldIndex](index);
        row[fields[fieldIndex + 1]] = accessors[fieldIndex + 1](index);
        row[fields[fieldIndex + 2]] = accessors[fieldIndex + 2](index);
        row[fields[fieldIndex + 3]] = accessors[fieldIndex + 3](index);
      }

      for (; fieldIndex < fieldCount; ++fieldIndex) {
        row[fields[fieldIndex]] = accessors[fieldIndex](index);
      }

      return row;
    };
  }

  function rowsFromColumns(columns, options) {
    options = options || {};

    var fields = inferFields(columns, options.fields);
    var length = inferLength(columns, fields, options.length);
    var transformedColumns = maybeTransformColumns(columns, fields, length, options.transforms);
    var accessors = new Array(fields.length);
    var accessorsByField = {};

    for (var accessorIndex = 0; accessorIndex < fields.length; ++accessorIndex) {
      accessors[accessorIndex] = getColumnAccessor(transformedColumns[fields[accessorIndex]]);
      accessorsByField[fields[accessorIndex]] = accessors[accessorIndex];
    }

    var rows = new Array(length);
    var batch = {
      accessors: accessors,
      accessorsByField: accessorsByField,
      columns: transformedColumns,
      fields: fields,
      length: length,
      materialized: new Uint8Array(length),
      rowFactory: typeof options.rowFactory === "function"
        ? options.rowFactory
        : createDefaultRowFactory(fields, accessors),
      rows: rows
    };

    Object.defineProperty(rows, COLUMNAR_BATCH_KEY, {
      configurable: true,
      enumerable: false,
      value: batch,
      writable: false
    });

    return new Proxy(rows, {
      get: function(target, prop, receiver) {
        if (prop === COLUMNAR_BATCH_KEY) {
          return batch;
        }
        if (isArrayIndex(prop)) {
          var index = Number(prop);
          if (index < 0 || index >= batch.length) {
            return undefined;
          }
          return materializeColumnarRow(batch, index);
        }
        return Reflect.get(target, prop, receiver);
      },
      has: function(target, prop) {
        if (isArrayIndex(prop)) {
          var index = Number(prop);
          return index >= 0 && index < batch.length;
        }
        return Reflect.has(target, prop);
      }
    });
  }

  function getArrowFieldNames(table, explicitFields) {
    if (explicitFields && explicitFields.length) {
      return explicitFields.slice();
    }

    if (table && table.schema && Array.isArray(table.schema.fields)) {
      return table.schema.fields.map(function(field) {
        return field.name;
      });
    }

    if (table && Array.isArray(table.columnNames)) {
      return table.columnNames.slice();
    }

    return [];
  }

  function getArrowColumn(table, fieldName, fieldIndex) {
    if (table == null) {
      return undefined;
    }
    if (typeof table.getChild === "function") {
      var byName = table.getChild(fieldName);
      if (byName != null) {
        return byName;
      }
    }
    if (typeof table.getColumn === "function") {
      var byColumn = table.getColumn(fieldName);
      if (byColumn != null) {
        return byColumn;
      }
    }
    if (typeof table.getChildAt === "function") {
      return table.getChildAt(fieldIndex);
    }
    return table[fieldName];
  }

  function rowsFromArrowTable(table, options) {
    options = options || {};

    var fields = getArrowFieldNames(table, options.fields);
    var columns = {};
    for (var i = 0; i < fields.length; ++i) {
      columns[fields[i]] = getArrowColumn(table, fields[i], i);
    }

    return rowsFromColumns(columns, {
      fields: fields,
      length: typeof table.numRows === "number" ? table.numRows : options.length,
      rowFactory: options.rowFactory,
      transforms: options.transforms
    });
  }

  var defaultRuntimeOptions = {
    wasm: true
  };

  var sharedRuntimeState = {
    error: null,
    runtime: null,
    supported: typeof WebAssembly !== 'undefined'
      && typeof WebAssembly.Module === 'function'
      && typeof WebAssembly.Instance === 'function'
  };

  var SMALL_TARGET_WASM_THRESHOLD = 4;
  var SMALL_DATA_WASM_THRESHOLD = 1000;
  var MAX_WASM_MARK_BYTES = 32 * 1024 * 1024;

  function arraysEqual(a, b) {
    if (a === b) return true;
    if (!a || !b || a.length !== b.length) return false;
    for (var i = 0; i < a.length; ++i) {
      if (a[i] !== b[i]) return false;
    }
    return true;
  }

  function encodeU32(value) {
    var bytes = [];
    do {
      var byte = value & 0x7f;
      value >>>= 7;
      if (value) {
        byte |= 0x80;
      }
      bytes.push(byte);
    } while (value);
    return bytes;
  }

  function encodeString(value) {
    var bytes = [];
    for (var i = 0; i < value.length; ++i) {
      bytes.push(value.charCodeAt(i));
    }
    return encodeU32(bytes.length).concat(bytes);
  }

  function encodeSection(id, payload) {
    return [id].concat(encodeU32(payload.length), payload);
  }

  function createFilterModuleBytes() {
    var typeSection = encodeSection(1, [].concat(
      encodeU32(2),
      [0x60],
      encodeU32(5),
      [0x7f, 0x7f, 0x7f, 0x7f, 0x7f],
      encodeU32(1),
      [0x7f],
      [0x60],
      encodeU32(6),
      [0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f],
      encodeU32(1),
      [0x7f]
    ));
    var functionSection = encodeSection(3, [].concat(encodeU32(2), encodeU32(0), encodeU32(1)));
    var memorySection = encodeSection(5, [].concat(encodeU32(1), [0x00], encodeU32(1)));
    var exportSection = encodeSection(7, [].concat(
      encodeU32(3),
      encodeString('memory'),
      [0x02],
      encodeU32(0),
      encodeString('filterInU32'),
      [0x00],
      encodeU32(0),
      encodeString('markFilterInU32'),
      [0x00],
      encodeU32(1)
    ));
    var filterSmallBody = [].concat(
      encodeU32(1),
      encodeU32(4),
      [0x7f],
      [0x41, 0x00, 0x21, 0x05],
      [0x41, 0x00, 0x21, 0x06],
      [0x02, 0x40],
      [0x03, 0x40],
      [0x20, 0x05, 0x20, 0x01, 0x49, 0x45, 0x0d, 0x01],
      [0x20, 0x00, 0x20, 0x05, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00, 0x21, 0x07],
      [0x41, 0x00, 0x21, 0x08],
      [0x02, 0x40],
      [0x03, 0x40],
      [0x20, 0x08, 0x20, 0x03, 0x49, 0x45, 0x0d, 0x01],
      [0x20, 0x07],
      [0x20, 0x02, 0x20, 0x08, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00],
      [0x46],
      [0x04, 0x40],
      [0x20, 0x04, 0x20, 0x06, 0x41, 0x04, 0x6c, 0x6a],
      [0x20, 0x05],
      [0x36, 0x02, 0x00],
      [0x20, 0x06, 0x41, 0x01, 0x6a, 0x21, 0x06],
      [0x0c, 0x02],
      [0x0b],
      [0x20, 0x08, 0x41, 0x01, 0x6a, 0x21, 0x08],
      [0x0c, 0x00],
      [0x0b],
      [0x0b],
      [0x20, 0x05, 0x41, 0x01, 0x6a, 0x21, 0x05],
      [0x0c, 0x00],
      [0x0b],
      [0x0b],
      [0x20, 0x06],
      [0x0b]
    );
    var filterMarkedBody = [].concat(
      encodeU32(1),
      encodeU32(3),
      [0x7f],
      [0x41, 0x00, 0x21, 0x06],
      [0x41, 0x00, 0x21, 0x07],
      [0x02, 0x40],
      [0x03, 0x40],
      [0x20, 0x07, 0x20, 0x03, 0x49, 0x45, 0x0d, 0x01],
      [0x20, 0x02, 0x20, 0x07, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00, 0x21, 0x08],
      [0x20, 0x04, 0x20, 0x08, 0x41, 0x04, 0x6c, 0x6a, 0x41, 0x01, 0x36, 0x02, 0x00],
      [0x20, 0x07, 0x41, 0x01, 0x6a, 0x21, 0x07],
      [0x0c, 0x00],
      [0x0b],
      [0x0b],
      [0x41, 0x00, 0x21, 0x07],
      [0x02, 0x40],
      [0x03, 0x40],
      [0x20, 0x07, 0x20, 0x01, 0x49, 0x45, 0x0d, 0x01],
      [0x20, 0x00, 0x20, 0x07, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00, 0x21, 0x08],
      [0x20, 0x04, 0x20, 0x08, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00, 0x41, 0x00, 0x47],
      [0x04, 0x40],
      [0x20, 0x05, 0x20, 0x06, 0x41, 0x04, 0x6c, 0x6a, 0x20, 0x07, 0x36, 0x02, 0x00],
      [0x20, 0x06, 0x41, 0x01, 0x6a, 0x21, 0x06],
      [0x0b],
      [0x20, 0x07, 0x41, 0x01, 0x6a, 0x21, 0x07],
      [0x0c, 0x00],
      [0x0b],
      [0x0b],
      [0x41, 0x00, 0x21, 0x07],
      [0x02, 0x40],
      [0x03, 0x40],
      [0x20, 0x07, 0x20, 0x03, 0x49, 0x45, 0x0d, 0x01],
      [0x20, 0x02, 0x20, 0x07, 0x41, 0x04, 0x6c, 0x6a, 0x28, 0x02, 0x00, 0x21, 0x08],
      [0x20, 0x04, 0x20, 0x08, 0x41, 0x04, 0x6c, 0x6a, 0x41, 0x00, 0x36, 0x02, 0x00],
      [0x20, 0x07, 0x41, 0x01, 0x6a, 0x21, 0x07],
      [0x0c, 0x00],
      [0x0b],
      [0x0b],
      [0x20, 0x06],
      [0x0b]
    );
    var codeSection = encodeSection(10, [].concat(
      encodeU32(2),
      encodeU32(filterSmallBody.length),
      filterSmallBody,
      encodeU32(filterMarkedBody.length),
      filterMarkedBody
    ));

    return new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00].concat(
      typeSection,
      functionSection,
      memorySection,
      exportSection,
      codeSection
    ));
  }

  function buildRuntime() {
    var module = new WebAssembly.Module(createFilterModuleBytes());
    var instance = new WebAssembly.Instance(module, {});

    return {
      cachedCodes: null,
      cachedCodesLength: 0,
      cachedTargets: null,
      cachedTargetsLength: 0,
      cachedTargetsOffset: 0,
      filterInU32: instance.exports.filterInU32,
      markFilterInU32: instance.exports.markFilterInU32,
      memory: instance.exports.memory,
      ensureCapacity: function(totalBytes) {
        var currentBytes = this.memory.buffer.byteLength;

        if (totalBytes <= currentBytes) {
          return this.memory.buffer;
        }

        var targetBytes = currentBytes;
        while (targetBytes < totalBytes) {
          targetBytes = targetBytes ? targetBytes * 2 : 65536;
        }

        var pagesNeeded = Math.ceil(targetBytes / 65536);
        var currentPages = currentBytes / 65536;

        this.memory.grow(pagesNeeded - currentPages);
        this.cachedCodes = null;
        this.cachedCodesLength = 0;
        this.cachedTargets = null;
        this.cachedTargetsLength = 0;
        this.cachedTargetsOffset = 0;

        return this.memory.buffer;
      },
      syncCodes: function(buffer, codes) {
        if (this.cachedCodes === codes && this.cachedCodesLength === codes.length) {
          return;
        }
        new Uint32Array(buffer, 0, codes.length).set(codes);
        this.cachedCodes = codes;
        this.cachedCodesLength = codes.length;
      },
      syncTargets: function(buffer, targetCodes, offset) {
        if (arraysEqual(this.cachedTargets, targetCodes)
            && this.cachedTargetsOffset === offset) {
          return;
        }
        new Uint32Array(buffer, offset, targetCodes.length).set(targetCodes);
        this.cachedTargets = targetCodes.slice ? targetCodes.slice() : Array.prototype.slice.call(targetCodes);
        this.cachedTargetsLength = targetCodes.length;
        this.cachedTargetsOffset = offset;
      },
      matchSmall: function(codes, targetCodes) {
        var dataBytes = codes.length * 4;
        var targetBytes = targetCodes.length * 4;
        var outPtr = dataBytes + targetBytes;
        var totalBytes = outPtr + dataBytes;
        var buffer = this.ensureCapacity(totalBytes);

        this.syncCodes(buffer, codes);
        this.syncTargets(buffer, targetCodes, dataBytes);

        var count = this.filterInU32(0, codes.length, dataBytes, targetCodes.length, outPtr);
        // SAFETY: returned view is only valid until next matchSmall/matchMarked call
        return new Uint32Array(buffer, outPtr, count);
      },
      matchMarked: function(codes, targetCodes, maxTargetCode) {
        var dataBytes = codes.length * 4;
        var targetBytes = targetCodes.length * 4;
        var marksBytes = (maxTargetCode + 1) * 4;
        var markPtr = dataBytes + targetBytes;
        var outPtr = markPtr + marksBytes;
        var totalBytes = outPtr + dataBytes;
        var buffer = this.ensureCapacity(totalBytes);

        this.syncCodes(buffer, codes);
        this.syncTargets(buffer, targetCodes, dataBytes);

        // Zero marks region — it may contain stale data from prior matchSmall output
        new Uint32Array(buffer, markPtr, maxTargetCode + 1).fill(0);

        var count = this.markFilterInU32(0, codes.length, dataBytes, targetCodes.length, markPtr, outPtr);
        // SAFETY: returned view is only valid until next matchSmall/matchMarked call
        return new Uint32Array(buffer, outPtr, count);
      }
    };
  }

  function getSharedRuntime(enabled) {
    if (!sharedRuntimeState.supported || !enabled) {
      return null;
    }

    if (!sharedRuntimeState.runtime) {
      try {
        sharedRuntimeState.runtime = buildRuntime();
        sharedRuntimeState.error = null;
      } catch (error) {
        sharedRuntimeState.error = error;
        sharedRuntimeState.runtime = null;
      }
    }

    return sharedRuntimeState.runtime;
  }

  function currentRuntimeInfo(enabled) {
    return {
      active: sharedRuntimeState.runtime && enabled ? 'wasm' : 'js',
      lastError: sharedRuntimeState.error ? String(sharedRuntimeState.error.message || sharedRuntimeState.error) : null,
      wasmEnabled: enabled !== false,
      wasmSupported: sharedRuntimeState.supported
    };
  }

  function ensureDenseLookupCapacity(state, size) {
    if (state.marks.length >= size) {
      return;
    }

    var nextSize = state.marks.length || 16;
    while (nextSize < size) {
      nextSize <<= 1;
    }

    var nextMarks = new Uint32Array(nextSize);
    nextMarks.set(state.marks);
    state.marks = nextMarks;
  }

  function ensureScratchCapacity(state, size) {
    if (state.scratch.length >= size) {
      return state.scratch;
    }

    var nextSize = state.scratch.length || 256;
    while (nextSize < size) {
      nextSize <<= 1;
    }

    state.scratch = new Uint32Array(nextSize);
    return state.scratch;
  }

  function denseLookupMatches(codes, targetCodes, state) {
    var matches = ensureScratchCapacity(state, codes.length);
    var count = 0;
    var i;

    if (targetCodes.length === 1) {
      var targetCode = targetCodes[0];
      for (i = 0; i < codes.length; ++i) {
        if (codes[i] === targetCode) {
          matches[count++] = i;
        }
      }
      return matches.slice(0, count);
    }

    var maxTargetCode = 0;
    for (i = 0; i < targetCodes.length; ++i) {
      if (targetCodes[i] > maxTargetCode) {
        maxTargetCode = targetCodes[i];
      }
    }

    ensureDenseLookupCapacity(state, maxTargetCode + 1);
    if (state.version === 0xffffffff) {
      state.marks.fill(0);
      state.version = 1;
    }

    var version = state.version++;
    var marks = state.marks;

    for (i = 0; i < targetCodes.length; ++i) {
      marks[targetCodes[i]] = version;
    }

    for (i = 0; i < codes.length; ++i) {
      if (marks[codes[i]] === version) {
        matches[count++] = i;
      }
    }

    return matches.slice(0, count);
  }

  function maxCodeValue(values) {
    var maxValue = 0;
    for (var valueIndex = 0; valueIndex < values.length; ++valueIndex) {
      if (values[valueIndex] > maxValue) {
        maxValue = values[valueIndex];
      }
    }
    return maxValue;
  }

  function createWasmRuntimeController(options) {
    var enabled = options && Object.prototype.hasOwnProperty.call(options, 'wasm')
      ? options.wasm !== false
      : defaultRuntimeOptions.wasm !== false;
    var denseLookupState = {
      marks: new Uint32Array(0),
      version: 1,
      scratch: new Uint32Array(0)
    };

    function configureRuntime(nextOptions) {
      if (nextOptions && Object.prototype.hasOwnProperty.call(nextOptions, 'wasm')) {
        enabled = nextOptions.wasm !== false;
      }
      return currentRuntimeInfo(enabled);
    }

    function runtimeInfo() {
      return currentRuntimeInfo(enabled);
    }

    function canUseWasmScan() {
      return !!getSharedRuntime(enabled);
    }

    function findMatches(codes, targetCodes) {
      if (!targetCodes.length) {
        return new Uint32Array(0);
      }

      var runtime = getSharedRuntime(enabled);
      var maxTargetCode;

      if (runtime) {
        var useSmall = targetCodes.length <= SMALL_TARGET_WASM_THRESHOLD
          && codes.length <= SMALL_DATA_WASM_THRESHOLD;

        if (useSmall) {
          try {
            return runtime.matchSmall(codes, targetCodes);
          } catch (error) {
            sharedRuntimeState.error = error;
            sharedRuntimeState.runtime = null;
          }
        }
      }

      if (runtime) {
        maxTargetCode = Math.max(maxCodeValue(targetCodes), maxCodeValue(codes));
        if ((maxTargetCode + 1) * 4 <= MAX_WASM_MARK_BYTES) {
          try {
            return runtime.matchMarked(codes, targetCodes, maxTargetCode);
          } catch (error) {
            sharedRuntimeState.error = error;
            sharedRuntimeState.runtime = null;
          }
        }
      }

      return denseLookupMatches(codes, targetCodes, denseLookupState);
    }

    return {
      canUseWasmScan: canUseWasmScan,
      configureRuntime: configureRuntime,
      findEncodedMatches: findMatches,
      runtimeInfo: runtimeInfo
    };
  }

  var defaultRuntimeController = createWasmRuntimeController();

  function configureWasmRuntime(options) {
    if (options && Object.prototype.hasOwnProperty.call(options, 'wasm')) {
      defaultRuntimeOptions.wasm = options.wasm !== false;
    }
    return defaultRuntimeController.configureRuntime(options);
  }

  function getWasmRuntimeInfo() {
    return defaultRuntimeController.runtimeInfo();
  }

  function isFiniteNumber(value) {
    return typeof value === "number" && Number.isFinite(value);
  }

  function uniqueFields(values) {
    var seen = new Set(),
        result = [];

    for (var i = 0; i < values.length; ++i) {
      if (!values[i] || seen.has(values[i])) {
        continue;
      }
      seen.add(values[i]);
      result.push(values[i]);
    }

    return result;
  }

  var TIME_BUCKET_MS = {
    minute: 60000,
    hour: 3600000,
    day: 86400000
  };

  function normalizeMetrics(metrics, prefix) {
    var normalized = (metrics && metrics.length ? metrics : [{ op: "count" }]).map(function(metric, metricIndex) {
      var id = metric.id || prefix + "_" + metricIndex;
      if (metric.op !== "count" && !metric.field) {
        throw new Error("Dashboard metric `" + id + "` requires a field.");
      }
      if (metric.op !== "count" && metric.op !== "sum" && metric.op !== "avg" && metric.op !== "avgNonZero") {
        throw new Error("Unsupported dashboard metric op: " + metric.op);
      }

      return {
        field: metric.field,
        id: id,
        op: metric.op || "count"
      };
    });

    return normalized;
  }

  function normalizeTimeBucketValue(value) {
    if (value == null) {
      return null;
    }

    if (value instanceof Date) {
      return value.getTime();
    }

    if (typeof value === "number") {
      return Number.isFinite(value) ? value : null;
    }

    var numeric = Number(value);
    if (Number.isFinite(numeric)) {
      return numeric;
    }

    var parsed = new Date(value).getTime();
    return Number.isFinite(parsed) ? parsed : null;
  }

  function bucketTimestampValue(value, granularity) {
    var numeric = normalizeTimeBucketValue(value);
    if (numeric == null) {
      return null;
    }

    if (granularity === "month") {
      var monthDate = new Date(numeric);
      return Date.UTC(monthDate.getUTCFullYear(), monthDate.getUTCMonth(), 1);
    }

    if (granularity === "week") {
      var weekDate = new Date(numeric);
      var day = weekDate.getUTCDay();
      var monday = new Date(Date.UTC(
        weekDate.getUTCFullYear(),
        weekDate.getUTCMonth(),
        weekDate.getUTCDate() - ((day + 6) % 7)
      ));
      return monday.getTime();
    }

    var step = TIME_BUCKET_MS[granularity];
    if (!step) {
      throw new Error("Unsupported dashboard time bucket granularity: " + granularity);
    }

    return Math.floor(numeric / step) * step;
  }

  function resolveGroupAccessor(spec) {
    if (!spec || !spec.bucket) {
      return null;
    }

    if (spec.bucket.type !== "timeBucket") {
      throw new Error("Unsupported dashboard group bucket type: " + spec.bucket.type);
    }

    var granularity = spec.bucket.granularity || "day";
    return function(value) {
      return bucketTimestampValue(value, granularity);
    };
  }

  function buildMetricReducer(metrics, splitField) {
    var metricSpec = metrics.map(function(metric) {
      return {
        field: metric.field || null,
        id: metric.id,
        op: metric.op
      };
    });

    function initBucket() {
      var bucket = {};
      for (var metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
        var metric = metrics[metricIndex];
        if (metric.op === "avg" || metric.op === "avgNonZero") {
          bucket[metric.id] = { count: 0, sum: 0 };
        } else {
          bucket[metric.id] = 0;
        }
      }
      return bucket;
    }

    function isBucketEmpty(bucket) {
      for (var metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
        var metric = metrics[metricIndex];
        var value = bucket[metric.id];
        if (metric.op === "avg" || metric.op === "avgNonZero") {
          if (value && value.count > 0) return false;
        } else if (metric.op === "count") {
          if (value > 0) return false;
        } else {
          if (value !== 0) return false;
        }
      }
      return true;
    }

    function addToBucket(bucket, row) {
      for (var metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
        var metric = metrics[metricIndex];
        var value;

        switch (metric.op) {
          case "count":
            bucket[metric.id] += 1;
            break;
          case "sum":
            value = row[metric.field];
            if (isFiniteNumber(value)) {
              bucket[metric.id] += value;
            }
            break;
          case "avg":
            value = row[metric.field];
            if (isFiniteNumber(value)) {
              bucket[metric.id].sum += value;
              bucket[metric.id].count += 1;
            }
            break;
          case "avgNonZero":
            value = row[metric.field];
            if (isFiniteNumber(value) && value !== 0) {
              bucket[metric.id].sum += value;
              bucket[metric.id].count += 1;
            }
            break;
        }
      }
    }

    function removeFromBucket(bucket, row) {
      for (var metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
        var metric = metrics[metricIndex];
        var value;

        switch (metric.op) {
          case "count":
            bucket[metric.id] -= 1;
            break;
          case "sum":
            value = row[metric.field];
            if (isFiniteNumber(value)) {
              bucket[metric.id] -= value;
            }
            break;
          case "avg":
            value = row[metric.field];
            if (isFiniteNumber(value)) {
              bucket[metric.id].sum -= value;
              bucket[metric.id].count -= 1;
            }
            break;
          case "avgNonZero":
            value = row[metric.field];
            if (isFiniteNumber(value) && value !== 0) {
              bucket[metric.id].sum -= value;
              bucket[metric.id].count -= 1;
            }
            break;
        }
      }
    }

    function finalizeBucket(bucket) {
      var result = {};
      for (var metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
        var metric = metrics[metricIndex];
        var value = bucket[metric.id];
        if (metric.op === "avg" || metric.op === "avgNonZero") {
          result[metric.id] = value.count ? value.sum / value.count : null;
        } else {
          result[metric.id] = value;
        }
      }
      return result;
    }

    // ---- Split-field path: nested aggregates keyed by splitField value ----

    if (splitField) {
      var splitInitial = function() {
        var state = {};
        Object.defineProperties(state, {
          __cache: { configurable: true, enumerable: false, value: null, writable: true },
          __cacheVersion: { configurable: true, enumerable: false, value: -1, writable: true },
          __version: { configurable: true, enumerable: false, value: 0, writable: true }
        });
        return state;
      };

      var splitAdd = function(state, row) {
        var splitKey = row[splitField];
        if (splitKey == null || splitKey === "") splitKey = "__unknown__";
        if (!state[splitKey]) state[splitKey] = initBucket();
        addToBucket(state[splitKey], row);
        state.__version += 1;
        return state;
      };

      var splitRemove = function(state, row) {
        var splitKey = row[splitField];
        if (splitKey == null || splitKey === "") splitKey = "__unknown__";
        if (state[splitKey]) removeFromBucket(state[splitKey], row);
        state.__version += 1;
        return state;
      };

      var splitFinalize = function(state) {
        if (state.__cacheVersion === state.__version && state.__cache) {
          return state.__cache;
        }
        var result = {};
        for (var key in state) {
          var bucket = state[key];
          // Skip buckets reduced to zero (filtered-out stores)
          if (isBucketEmpty(bucket)) continue;
          result[key] = finalizeBucket(bucket);
        }
        state.__cache = result;
        state.__cacheVersion = state.__version;
        return result;
      };

      // Do NOT attach _xfilterMetricSpec — the metricSpec fast path in
      // crossfilter core bypasses custom reducers, which we need for split.

      return { add: splitAdd, finalize: splitFinalize, initial: splitInitial, remove: splitRemove };
    }

    // ---- Standard path: flat metrics ----

    function initial() {
      var state = initBucket();

      Object.defineProperties(state, {
        __cache: {
          configurable: true,
          enumerable: false,
          value: null,
          writable: true
        },
        __cacheVersion: {
          configurable: true,
          enumerable: false,
          value: -1,
          writable: true
        },
        __version: {
          configurable: true,
          enumerable: false,
          value: 0,
          writable: true
        }
      });

      return state;
    }

    function add(state, row) {
      addToBucket(state, row);
      state.__version += 1;
      return state;
    }

    function remove(state, row) {
      removeFromBucket(state, row);
      state.__version += 1;
      return state;
    }

    function finalize(state) {
      if (state.__cacheVersion === state.__version && state.__cache) {
        return state.__cache;
      }

      var result = finalizeBucket(state);

      state.__cache = result;
      state.__cacheVersion = state.__version;
      return result;
    }

    add._xfilterMetricSpec = metricSpec;
    remove._xfilterMetricSpec = metricSpec;
    initial._xfilterMetricSpec = metricSpec;

    return {
      add: add,
      finalize: finalize,
      initial: initial,
      remove: remove
    };
  }

  function getNativeSumMetric(metrics) {
    return metrics && metrics.length === 1 && metrics[0].op === "sum"
      ? metrics[0]
      : null;
  }

  function createNativeSumAccessor(metric) {
    return function(row) {
      var value = row[metric.field];
      return isFiniteNumber(value) ? value : 0;
    };
  }

  function normalizeFilter(filter) {
    if (!filter || filter.type === "all") {
      return null;
    }

    if (filter.type === "exact") {
      return {
        type: "exact",
        value: filter.value
      };
    }

    if (filter.type === "in") {
      return {
        type: "in",
        values: Array.isArray(filter.values) ? filter.values.slice() : []
      };
    }

    if (filter.type === "range") {
      return {
        range: Array.isArray(filter.range) ? filter.range.slice() : [],
        type: "range"
      };
    }

    throw new Error("Unsupported dashboard filter type: " + filter.type);
  }

  function shallowCopy(obj) {
    var copy = {};
    for (var key in obj) {
      copy[key] = obj[key];
    }
    return copy;
  }

  function normalizeFilterState(filters) {
    var normalized = {};

    if (!filters) {
      return normalized;
    }

    for (var field in filters) {
      normalized[field] = normalizeFilter(filters[field]);
    }

    return normalized;
  }

  function sameFilter(left, right) {
    if (left === right) {
      return true;
    }
    if (!left || !right) {
      return !left && !right;
    }
    if (left.type !== right.type) {
      return false;
    }

    if (left.type === "exact") {
      return left.value === right.value;
    }

    var leftValues = left.type === "range" ? left.range : left.values;
    var rightValues = right.type === "range" ? right.range : right.values;

    if (!leftValues || !rightValues || leftValues.length !== rightValues.length) {
      return false;
    }

    for (var valueIndex = 0; valueIndex < leftValues.length; ++valueIndex) {
      if (leftValues[valueIndex] !== rightValues[valueIndex]) {
        return false;
      }
    }

    return true;
  }

  function applyFilter(dimension, filter) {
    if (!filter) {
      dimension.filterAll();
      return;
    }

    switch (filter.type) {
      case "exact":
        dimension.filterExact(filter.value);
        return;
      case "in":
        dimension.filterIn(filter.values);
        return;
      case "range":
        dimension.filterRange(filter.range);
        return;
    }
  }

  function normalizeGroupQuery(query) {
    if (query == null || query === true) {
      return null;
    }
    if (query === false) {
      return false;
    }

    return {
      includeKeys: Array.isArray(query.includeKeys) && query.includeKeys.length ? query.includeKeys.slice() : null,
      includeTotals: query.includeTotals !== false,
      keys: Array.isArray(query.keys) && query.keys.length ? query.keys.slice() : null,
      limit: typeof query.limit === "number" && query.limit >= 0 ? Math.floor(query.limit) : null,
      nonEmptyKeys: query.nonEmptyKeys === true,
      offset: typeof query.offset === "number" && query.offset >= 0 ? Math.floor(query.offset) : 0,
      search: typeof query.search === "string" && query.search ? query.search.toLowerCase() : null,
      sort: query.sort === "asc" || query.sort === "natural" ? query.sort : "desc",
      sortMetric: query.sortMetric || null,
      visibleOnly: query.visibleOnly !== false
    };
  }

  function metricComparableValue(metric, value) {
    if (!metric) {
      return 0;
    }

    if (metric.op === "avg" || metric.op === "avgNonZero") {
      return value && value.count ? value.sum / value.count : null;
    }

    return typeof value === "number" ? value : 0;
  }

  function metricHasVisibleValue(metric, value) {
    var comparable = metricComparableValue(metric, value);
    return comparable != null && comparable > 0;
  }

  function compareGroupKeys(left, right) {
    if (left === right) {
      return 0;
    }
    return String(left).localeCompare(String(right));
  }

  function insertSortedEntry(entries, entry, compare, maxSize) {
    var insertIndex = entries.length;

    if (maxSize != null && entries.length >= maxSize && compare(entry, entries[entries.length - 1]) >= 0) {
      return;
    }

    while (insertIndex > 0 && compare(entry, entries[insertIndex - 1]) < 0) {
      insertIndex -= 1;
    }

    entries.splice(insertIndex, 0, entry);
    if (maxSize != null && entries.length > maxSize) {
      entries.pop();
    }
  }

  function createKpiRuntime(cf, metrics) {
    var nativeSumMetric = getNativeSumMetric(metrics);
    var reducer = nativeSumMetric ? null : buildMetricReducer(metrics);
    var group = nativeSumMetric && typeof cf.groupAll === "function"
      ? cf.groupAll().reduceSum(createNativeSumAccessor(nativeSumMetric))
      : cf.groupAll().reduce(reducer.add, reducer.remove, reducer.initial);

    return {
      dispose: function() {
        group.dispose();
      },
      read: function() {
        if (nativeSumMetric) {
          var result = {};
          result[nativeSumMetric.id] = group.value();
          return result;
        }
        return reducer.finalize(group.value());
      }
    };
  }

  function createGroupRuntime(dimension, spec, index) {
    var metrics = normalizeMetrics(spec.metrics, spec.id || "group_" + index);
    var metricsById = {};
    var metricIndex;
    var splitField = spec.splitField || null;
    var nativeSumMetric = splitField ? null : getNativeSumMetric(metrics);
    var reducer = nativeSumMetric ? null : buildMetricReducer(metrics, splitField);
    var groupAccessor = resolveGroupAccessor(spec);
    var group = groupAccessor ? dimension.group(groupAccessor) : dimension.group();
    var visibleMetric = null;
    var defaultSortMetric = null;
    var orderedMetricId = null;
    if (nativeSumMetric && typeof group.reduceSum === "function") {
      group.reduceSum(createNativeSumAccessor(nativeSumMetric));
    } else {
      group.reduce(reducer.add, reducer.remove, reducer.initial);
    }

    for (metricIndex = 0; metricIndex < metrics.length; ++metricIndex) {
      metricsById[metrics[metricIndex].id] = metrics[metricIndex];
      if (!visibleMetric && metrics[metricIndex].op === "count") {
        visibleMetric = metrics[metricIndex];
      }
    }

    if (!visibleMetric) {
      visibleMetric = metrics[0] || null;
    }
    defaultSortMetric = metricsById[spec.sortMetric] || metricsById.rows || metrics[0] || null;

    function metricStateValue(value, metric) {
      if (!metric) {
        return 0;
      }
      if (nativeSumMetric) {
        return metric.id === nativeSumMetric.id ? value : 0;
      }
      if (splitField) {
        // Sum the metric across all split buckets for comparability
        var total = 0;
        for (var splitKey in value) {
          var bucket = value[splitKey];
          if (bucket && bucket[metric.id] != null) {
            var bv = bucket[metric.id];
            if (typeof bv === "object" && bv.count != null) {
              total += bv.sum || 0;
            } else {
              total += bv;
            }
          }
        }
        return total;
      }
      return value ? value[metric.id] : 0;
    }

    function entryMetricValue(entry, metric) {
      return entry ? metricStateValue(entry.value, metric) : 0;
    }

    function finalizeEntryValue(value) {
      if (!nativeSumMetric) {
        return reducer.finalize(value);
      }

      var result = {};
      result[nativeSumMetric.id] = value;
      return result;
    }

    function finalizeEntry(entry) {
      return {
        key: entry.key,
        value: finalizeEntryValue(entry.value)
      };
    }

    function readAll() {
      return group.all().map(finalizeEntry);
    }

    function matchesGroupKey(key, query, keySet, forceInclude) {
      if (!forceInclude && query.nonEmptyKeys && (key == null || key === "")) {
        return false;
      }
      if (!forceInclude && keySet && !keySet.has(key)) {
        return false;
      }
      if (!forceInclude && query.search && String(key).toLowerCase().indexOf(query.search) < 0) {
        return false;
      }
      return true;
    }

    function compareEntries(query, sortMetric, left, right) {
      var diff = metricComparableValue(sortMetric, entryMetricValue(left, sortMetric)) - metricComparableValue(sortMetric, entryMetricValue(right, sortMetric));
      if (!Number.isFinite(diff) || diff === 0) {
        return compareGroupKeys(left.key, right.key);
      }
      return query.sort === "asc" ? diff : -diff;
    }

    function topComparableValue(sortMetric, entry) {
      var comparable = metricComparableValue(sortMetric, entryMetricValue(entry, sortMetric));
      return comparable == null ? Number.NEGATIVE_INFINITY : comparable;
    }

    function ensureTopOrder(sortMetric) {
      if (!sortMetric || typeof group.order !== "function" || typeof group.top !== "function") {
        return false;
      }
      if (orderedMetricId === sortMetric.id) {
        return true;
      }
      group.order(function(value) {
        var comparable = metricComparableValue(sortMetric, metricStateValue(value, sortMetric));
        return comparable == null ? Number.NEGATIVE_INFINITY : comparable;
      });
      orderedMetricId = sortMetric.id;
      return true;
    }

    function canUseTopQuery(normalized, sortMetric) {
      return !!(
        normalized
        && normalized.sort === "desc"
        && sortMetric
        && normalized.includeTotals === false
        && !normalized.includeKeys
        && !normalized.keys
        && !normalized.search
        && typeof group.size === "function"
        && ensureTopOrder(sortMetric)
      );
    }

    function readTopQuery(normalized, sortMetric) {
      var limitWindow = normalized.limit == null ? null : normalized.offset + normalized.limit;
      var groupSize = group.size();
      var requested = limitWindow == null
        ? groupSize
        : Math.min(groupSize, Math.max(limitWindow + 1, 32));
      var rawEntries;
      var filteredEntries;

      do {
        rawEntries = group.top(requested);
        filteredEntries = [];

        for (var rawIndex = 0; rawIndex < rawEntries.length; ++rawIndex) {
          var rawEntry = rawEntries[rawIndex];
          var visible = !normalized.visibleOnly || metricHasVisibleValue(visibleMetric, entryMetricValue(rawEntry, visibleMetric));
          if (visible && matchesGroupKey(rawEntry.key, normalized, null, false)) {
            filteredEntries.push(rawEntry);
          }
        }

        filteredEntries.sort(function(left, right) {
          return compareEntries(normalized, sortMetric, left, right);
        });

        if (limitWindow == null || requested >= groupSize) {
          break;
        }

        var shouldExpand = filteredEntries.length < limitWindow;
        if (!shouldExpand) {
          var boundaryEntry = filteredEntries[limitWindow - 1];
          shouldExpand = !!boundaryEntry
            && topComparableValue(sortMetric, rawEntries[rawEntries.length - 1]) >= topComparableValue(sortMetric, boundaryEntry);
        }

        if (!shouldExpand) {
          break;
        }

        requested = Math.min(groupSize, Math.max(requested + 32, requested * 2));
      } while (true);

      return {
        entries: (normalized.limit == null
          ? filteredEntries.slice(normalized.offset)
          : filteredEntries.slice(normalized.offset, normalized.offset + normalized.limit)).map(finalizeEntry),
        limit: normalized.limit,
        offset: normalized.offset,
        sort: normalized.sort,
        sortMetric: sortMetric ? sortMetric.id : null
      };
    }

    function readQuery(query) {
      var normalized = normalizeGroupQuery(query);
      var allEntries;
      var includeKeySet;
      var keySet;
      var matchedEntries = [];
      var forcedEntries = [];
      var sortMetric = metricsById[normalized && normalized.sortMetric] || defaultSortMetric;
      var limitWindow = null;
      var useBoundedSort = false;
      var compareMatchedEntries = null;
      var entryIndex;
      var total = 0;

      if (!normalized) {
        return readAll();
      }

      if (canUseTopQuery(normalized, sortMetric)) {
        return readTopQuery(normalized, sortMetric);
      }

      allEntries = group.all();
      includeKeySet = normalized.includeKeys ? new Set(normalized.includeKeys) : null;
      keySet = normalized.keys ? new Set(normalized.keys) : null;
      limitWindow = normalized.limit == null ? null : normalized.offset + normalized.limit;
      useBoundedSort = limitWindow != null && normalized.sort !== "natural" && !!sortMetric;
      if (normalized.sort !== "natural" && sortMetric) {
        compareMatchedEntries = function(left, right) {
          return compareEntries(normalized, sortMetric, left, right);
        };
      }

      for (entryIndex = 0; entryIndex < allEntries.length; ++entryIndex) {
        var entry = allEntries[entryIndex];
        var forceInclude = includeKeySet && includeKeySet.has(entry.key);
        var visible = !normalized.visibleOnly || metricHasVisibleValue(visibleMetric, entryMetricValue(entry, visibleMetric));
        var matchesBaseQuery = visible && matchesGroupKey(entry.key, normalized, keySet, false);

        if (matchesBaseQuery) {
          total += 1;
          if (useBoundedSort) {
            insertSortedEntry(matchedEntries, entry, compareMatchedEntries, limitWindow);
          } else {
            matchedEntries.push(entry);
          }
        }

        if (forceInclude) {
          forcedEntries.push(entry);
        }
      }

      if (normalized.sort !== "natural" && sortMetric && !useBoundedSort) {
        matchedEntries.sort(function(left, right) {
          return compareEntries(normalized, sortMetric, left, right);
        });
      }

      if (normalized.sort !== "natural" && sortMetric) {
        forcedEntries.sort(function(left, right) {
          return compareEntries(normalized, sortMetric, left, right);
        });
      }

      var pagedEntries = normalized.limit == null
        ? matchedEntries.slice(normalized.offset)
        : matchedEntries.slice(normalized.offset, normalized.offset + normalized.limit);
      var seenKeys = new Set();
      var mergedEntries = [];

      for (entryIndex = 0; entryIndex < pagedEntries.length; ++entryIndex) {
        mergedEntries.push(pagedEntries[entryIndex]);
        seenKeys.add(pagedEntries[entryIndex].key);
      }

      for (entryIndex = 0; entryIndex < forcedEntries.length; ++entryIndex) {
        if (seenKeys.has(forcedEntries[entryIndex].key)) {
          continue;
        }
        mergedEntries.push(forcedEntries[entryIndex]);
        seenKeys.add(forcedEntries[entryIndex].key);
      }

      if (normalized.sort !== "natural" && sortMetric && forcedEntries.length) {
        mergedEntries.sort(function(left, right) {
          return compareEntries(normalized, sortMetric, left, right);
        });
      }

      var result = {
        entries: mergedEntries.map(finalizeEntry),
        limit: normalized.limit,
        offset: normalized.offset,
        sort: normalized.sort,
        sortMetric: sortMetric ? sortMetric.id : null
      };

      if (normalized.includeTotals) {
        result.total = total;
      }

      return result;
    }

    return {
      dispose: function() {
        group.dispose();
      },
      id: spec.id || "group_" + index,
      read: function(query) {
        return readQuery(query);
      }
    };
  }

  function createCrossfilterInstance(crossfilter, options) {
    if (options.table) {
      return crossfilter.fromArrowTable(options.table, options.columnarOptions);
    }
    if (options.columns) {
      return crossfilter.fromColumns(options.columns, options.columnarOptions);
    }
    return crossfilter(options.records || []);
  }

  function appendColumns(crossfilter, cf, columns, options) {
    cf.add(crossfilter.rowsFromColumns(columns || {}, options || {}));
    return cf.size();
  }

  function appendArrowTable(crossfilter, cf, table, options) {
    cf.add(crossfilter.rowsFromArrowTable(table, options || {}));
    return cf.size();
  }

  function normalizeRowQuery(query) {
    query = query || {};

    return {
      columnar: query.columnar === true,
      direction: query.direction === "bottom" ? "bottom" : "top",
      fields: Array.isArray(query.fields) && query.fields.length ? query.fields.slice() : null,
      limit: typeof query.limit === "number" && query.limit >= 0 ? Math.floor(query.limit) : 50,
      offset: typeof query.offset === "number" && query.offset >= 0 ? Math.floor(query.offset) : 0,
      sortBy: query.sortBy || null
    };
  }

  function normalizeBoundsQuery(query) {
    query = query || {};

    return {
      fields: Array.isArray(query.fields) && query.fields.length ? uniqueFields(query.fields) : []
    };
  }

  function readColumnarFirstValue(result, field) {
    if (!result || !result.columns || !result.length) {
      return null;
    }

    var column = result.columns[field];
    if (!column || !column.length) {
      return null;
    }

    return column[0];
  }

  function projectRows(rows, fields) {
    if (!fields) {
      return rows.slice();
    }

    return rows.map(function(row) {
      var projected = {};
      for (var fieldIndex = 0; fieldIndex < fields.length; ++fieldIndex) {
        projected[fields[fieldIndex]] = row[fields[fieldIndex]];
      }
      return projected;
    });
  }

  function rowIndexesToColumns(cf, rowIndexes, fields) {
    if (typeof cf.takeColumns === "function") {
      return cf.takeColumns(rowIndexes, fields);
    }

    var allRows = cf.all();
    var columns = {};
    var fieldIndex;
    var rowIndex;

    for (fieldIndex = 0; fieldIndex < fields.length; ++fieldIndex) {
      columns[fields[fieldIndex]] = new Array(rowIndexes.length);
    }

    for (rowIndex = 0; rowIndex < rowIndexes.length; ++rowIndex) {
      var row = allRows[rowIndexes[rowIndex]];
      for (fieldIndex = 0; fieldIndex < fields.length; ++fieldIndex) {
        columns[fields[fieldIndex]][rowIndex] = row ? row[fields[fieldIndex]] : undefined;
      }
    }

    return {
      columns: columns,
      fields: fields ? fields.slice() : [],
      length: rowIndexes.length
    };
  }

  function ensureDimension(dimensions, dimensionFields, cf, field) {
    if (!dimensions[field]) {
      dimensions[field] = cf.dimension(field);
      dimensionFields.push(field);
    }
    return dimensions[field];
  }

  function createDashboardRuntime(crossfilter, options) {
    options = options || {};

    var sourceCount = (options.table ? 1 : 0) + (options.columns ? 1 : 0) + (options.records ? 1 : 0);
    if (sourceCount > 1) {
      throw new Error("createDashboardRuntime expects at most one of `table`, `columns` or `records`.");
    }

    var cf = createCrossfilterInstance(crossfilter, options);

    if (typeof cf.configureRuntime === "function") {
      cf.configureRuntime({ wasm: options.wasm !== false });
    } else {
      crossfilter.configureRuntime({ wasm: options.wasm !== false });
    }

    var groupSpecs = options.groups || [];
    var dimensionFields = uniqueFields((options.dimensions || []).concat(groupSpecs.map(function(group) {
      return group.field;
    })));
    var dimensions = {};
    var currentFilters = {};
    var groupRuntimes = {};
    var kpiRuntime = createKpiRuntime(cf, normalizeMetrics(options.kpis, "kpi"));
    var rowCountGroup = cf.groupAll().reduceCount();

    for (var fieldIndex = 0; fieldIndex < dimensionFields.length; ++fieldIndex) {
      dimensions[dimensionFields[fieldIndex]] = cf.dimension(dimensionFields[fieldIndex]);
    }

    var nextGroupIndex = 0;
    for (nextGroupIndex = 0; nextGroupIndex < groupSpecs.length; ++nextGroupIndex) {
      var groupSpec = groupSpecs[nextGroupIndex];
      var groupDimension = ensureDimension(dimensions, dimensionFields, cf, groupSpec.field);
      var groupRuntime = createGroupRuntime(groupDimension, groupSpec, nextGroupIndex);
      groupRuntimes[groupRuntime.id] = groupRuntime;
    }

    function updateFilters(filters) {
      var nextFilters = normalizeFilterState(filters);
      var seen = new Set();
      var operations = [];
      var clearFields = [];
      var changedCount = 0;

      for (var field in nextFilters) {
        if (!dimensions[field]) {
          throw new Error("Unknown dashboard filter dimension: " + field);
        }
        seen.add(field);
        if (!sameFilter(currentFilters[field], nextFilters[field])) {
          operations.push({
            dimension: dimensions[field],
            filter: nextFilters[field]
          });
          changedCount += 1;
        }
      }

      for (field in currentFilters) {
        if (seen.has(field)) {
          continue;
        }
        if (dimensions[field]) {
          clearFields.push(field);
          changedCount += 1;
        }
      }

      var applyOperations = function() {
        var operationIndex;
        for (operationIndex = 0; operationIndex < operations.length; ++operationIndex) {
          applyFilter(operations[operationIndex].dimension, operations[operationIndex].filter);
        }
        for (operationIndex = 0; operationIndex < clearFields.length; ++operationIndex) {
          dimensions[clearFields[operationIndex]].filterAll();
        }
      };

      if (changedCount > 1 && typeof cf.batch === "function") {
        cf.batch(applyOperations);
      } else {
        applyOperations();
      }

      currentFilters = nextFilters;
      return typeof cf.runtimeInfo === "function" ? cf.runtimeInfo() : crossfilter.runtimeInfo();
    }

    function readGroups(groupQueries) {
      var groups = {};

      if (!groupQueries) {
        for (var groupId in groupRuntimes) {
          groups[groupId] = groupRuntimes[groupId].read();
        }
        return groups;
      }

      for (var requestedGroupId in groupQueries) {
        if (!groupRuntimes[requestedGroupId]) {
          throw new Error("Unknown dashboard group: " + requestedGroupId);
        }
        if (groupQueries[requestedGroupId] === false) {
          continue;
        }
        groups[requestedGroupId] = groupRuntimes[requestedGroupId].read(groupQueries[requestedGroupId]);
      }

      return groups;
    }

    function readSnapshot(options) {
      var groups = {};

      if (!options || options.groups !== false) {
        groups = readGroups(options && options.groups ? options.groups : null);
      }

      return {
        groups: groups,
        kpis: kpiRuntime.read(),
        runtime: typeof cf.runtimeInfo === "function" ? cf.runtimeInfo() : crossfilter.runtimeInfo()
      };
    }

    function readRowCount() {
      return rowCountGroup.value();
    }

    function readRows(query) {
      var normalized = normalizeRowQuery(query);
      var rowIndexes;
      var rows;

      if (normalized.columnar) {
        if (!normalized.fields) {
          throw new Error("Columnar row queries require `fields`.");
        }
        if (normalized.sortBy) {
          var columnDimension = ensureDimension(dimensions, dimensionFields, cf, normalized.sortBy);
          rowIndexes = normalized.direction === "bottom" && typeof columnDimension.bottomIndex === "function"
            ? columnDimension.bottomIndex(normalized.limit, normalized.offset)
            : typeof columnDimension.topIndex === "function"
              ? columnDimension.topIndex(normalized.limit, normalized.offset)
              : null;
        } else if (typeof cf.allFilteredIndexes === "function") {
          rowIndexes = cf.allFilteredIndexes().slice(normalized.offset, normalized.offset + normalized.limit);
        }

        if (rowIndexes) {
          return rowIndexesToColumns(cf, rowIndexes, normalized.fields);
        }
      }

      if (normalized.sortBy) {
        var dimension = ensureDimension(dimensions, dimensionFields, cf, normalized.sortBy);
        rows = normalized.direction === "bottom"
          ? dimension.bottom(normalized.limit, normalized.offset)
          : dimension.top(normalized.limit, normalized.offset);
      } else {
        var allRows = typeof cf.allFiltered === "function" ? cf.allFiltered() : cf.all();
        rows = allRows.slice(normalized.offset, normalized.offset + normalized.limit);
      }

      return projectRows(rows, normalized.fields);
    }

    function readBounds(query) {
      var normalized = normalizeBoundsQuery(query);
      var bounds = {};
      var fieldIndex;

      for (fieldIndex = 0; fieldIndex < normalized.fields.length; ++fieldIndex) {
        var field = normalized.fields[fieldIndex];
        var dimension = ensureDimension(dimensions, dimensionFields, cf, field);
        var lowerIndexes = typeof dimension.bottomIndex === "function" ? dimension.bottomIndex(1) : null;
        var upperIndexes = typeof dimension.topIndex === "function" ? dimension.topIndex(1) : null;
        var minValue = null;
        var maxValue = null;

        if (lowerIndexes && lowerIndexes.length) {
          minValue = readColumnarFirstValue(rowIndexesToColumns(cf, [lowerIndexes[0]], [field]), field);
        } else {
          var lowerRows = dimension.bottom(1);
          minValue = lowerRows.length ? lowerRows[0][field] : null;
        }

        if (upperIndexes && upperIndexes.length) {
          maxValue = readColumnarFirstValue(rowIndexesToColumns(cf, [upperIndexes[0]], [field]), field);
        } else {
          var upperRows = dimension.top(1);
          maxValue = upperRows.length ? upperRows[0][field] : null;
        }

        bounds[field] = {
          max: maxValue == null ? null : maxValue,
          min: minValue == null ? null : minValue
        };
      }

      return bounds;
    }

    function readRowSets(rowSetQueries) {
      var rowSets = {};

      if (!rowSetQueries) {
        return rowSets;
      }

      for (var rowSetId in rowSetQueries) {
        if (rowSetQueries[rowSetId] === false) {
          continue;
        }
        rowSets[rowSetId] = readRows(rowSetQueries[rowSetId]);
      }

      return rowSets;
    }

    function queryRuntime(request) {
      request = request || {};

      var savedFilters = null;
      if (request.isolatedFilters) {
        savedFilters = shallowCopy(currentFilters);
        updateFilters(request.isolatedFilters);
      } else if (request.filters) {
        updateFilters(request.filters);
      }

      var response = {
        rows: request.rows ? readRows(request.rows) : [],
        snapshot: request.snapshot === false ? null : readSnapshot(request.snapshot)
      };

      if (request.rowCount) {
        response.rowCount = readRowCount();
      }

      if (request.groups) {
        response.groups = readGroups(request.groups);
      }

      if (request.bounds) {
        response.bounds = readBounds(request.bounds);
      }

      if (request.rowSets) {
        response.rowSets = readRowSets(request.rowSets);
      }

      if (savedFilters) {
        updateFilters(savedFilters);
      }

      return response;
    }

    function queryGroups(request) {
      request = request || {};
      if (request.filters) {
        updateFilters(request.filters);
      }
      return readGroups(request.groups || null);
    }

    function queryBounds(request) {
      request = request || {};
      if (request.filters) {
        updateFilters(request.filters);
      }
      return readBounds(request.bounds || request);
    }

    function queryRowSets(request) {
      request = request || {};
      if (request.filters) {
        updateFilters(request.filters);
      }
      return readRowSets(request.rowSets || request);
    }

    function removeFiltered(selection) {
      if (selection === "excluded") {
        cf.remove(function(_, index) {
          return typeof cf.isElementFiltered === "function" ? !cf.isElementFiltered(index) : false;
        });
      } else {
        cf.remove();
      }
      return cf.size();
    }

    return {
      append: function(records) {
        cf.add(records || []);
        return cf.size();
      },
      appendArrowTable: function(table, columnarOptions) {
        return appendArrowTable(crossfilter, cf, table, columnarOptions);
      },
      appendColumns: function(columns, columnarOptions) {
        return appendColumns(crossfilter, cf, columns, columnarOptions);
      },
      bounds: function(request) {
        return queryBounds(request);
      },
      dispose: function() {
        this.reset();
        for (var groupId in groupRuntimes) {
          groupRuntimes[groupId].dispose();
        }
        kpiRuntime.dispose();
        rowCountGroup.dispose();
        for (var dimensionIndex = 0; dimensionIndex < dimensionFields.length; ++dimensionIndex) {
          dimensions[dimensionFields[dimensionIndex]].dispose();
        }
      },
      createGroup: function(spec) {
        var groupDimension = ensureDimension(dimensions, dimensionFields, cf, spec.field);
        var groupRuntime = createGroupRuntime(groupDimension, spec, nextGroupIndex++);
        groupRuntimes[groupRuntime.id] = groupRuntime;
        return groupRuntime.id;
      },
      disposeGroup: function(id) {
        if (groupRuntimes[id]) {
          groupRuntimes[id].dispose();
          delete groupRuntimes[id];
        }
      },
      query: function(request) {
        return queryRuntime(request);
      },
      groups: function(request) {
        return queryGroups(request);
      },
      removeFiltered: function(selection) {
        return removeFiltered(selection);
      },
      reset: function() {
        return updateFilters({});
      },
      rows: function(query) {
        return readRows(query);
      },
      rowSets: function(request) {
        return queryRowSets(request);
      },
      rowCount: function(request) {
        request = request || {};
        if (request.filters) {
          updateFilters(request.filters);
        }
        return readRowCount();
      },
      runtimeInfo: function() {
        return typeof cf.runtimeInfo === "function" ? cf.runtimeInfo() : crossfilter.runtimeInfo();
      },
      size: function() {
        return cf.size();
      },
      snapshot: function(filters, snapshotOptions) {
        if (filters) {
          updateFilters(filters);
        }
        return readSnapshot(snapshotOptions);
      },
      updateFilters: updateFilters
    };
  }

  function resolveArrowBuffer$1(source) {
    if (source instanceof ArrayBuffer) {
      return source;
    }

    if (ArrayBuffer.isView(source)) {
      var view = source;
      if (view.byteOffset === 0 && view.byteLength === view.buffer.byteLength) {
        return view.buffer;
      }
      return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
    }

    throw new Error("createDashboardWorker expects `arrowBuffer` to be an ArrayBuffer or typed array view.");
  }

  function resolveAssetUrl$1(url) {
    if (typeof URL === "function" && typeof location !== "undefined" && location && location.href) {
      return new URL(url, location.href).toString();
    }
    return url;
  }

  function createWorkerSource$1(crossfilterUrl, arrowUrl) {
    return [
      "'use strict';",
      "importScripts(" + JSON.stringify(crossfilterUrl) + ", " + JSON.stringify(arrowUrl) + ");",
      "var runtime = null;",
      "function getTableFromIPC(module) {",
      "  return module && (module.tableFromIPC || (module.default && module.default.tableFromIPC)) || null;",
      "}",
      "function collectRowTransferables(obj) {",
      "  var buffers = [];",
      "  if (!obj || typeof obj !== 'object' || !obj.columns) return buffers;",
      "  for (var field in obj.columns) {",
      "    if (Object.prototype.hasOwnProperty.call(obj.columns, field)) {",
      "      var col = obj.columns[field];",
      "      if (ArrayBuffer.isView(col) && col.buffer) buffers.push(col.buffer);",
      "    }",
      "  }",
      "  return buffers;",
      "}",
      "function collectResponseTransferables(payload) {",
      "  if (!payload || typeof payload !== 'object') return [];",
      "  var seen = [];",
      "  var buffers = [];",
      "  function add(obj) {",
      "    var found = collectRowTransferables(obj);",
      "    for (var i = 0; i < found.length; ++i) {",
      "      if (seen.indexOf(found[i]) < 0) {",
      "        seen.push(found[i]);",
      "        buffers.push(found[i]);",
      "      }",
      "    }",
      "  }",
      "  add(payload);",
      "  if (payload.rows) add(payload.rows);",
      "  if (payload.rowSets) {",
      "    for (var setId in payload.rowSets) {",
      "      if (Object.prototype.hasOwnProperty.call(payload.rowSets, setId)) {",
      "        add(payload.rowSets[setId]);",
      "      }",
      "    }",
      "  }",
      "  return buffers;",
      "}",
      "function respond(id, payload) {",
      "  var transferables = collectResponseTransferables(payload);",
      "  self.postMessage({ id: id, ok: true, payload: payload }, transferables);",
      "}",
      "function fail(id, error) {",
      "  self.postMessage({ id: id, ok: false, error: {",
      "    message: String(error && error.message || error),",
      "    stack: error && error.stack ? String(error.stack) : null",
      "  } });",
      "}",
      "self.onmessage = async function(event) {",
      "  var message = event.data || {};",
      "  var id = message.id;",
      "  try {",
      "    if (message.type !== 'init' && message.type !== 'dispose') {",
      "      if (!runtime) throw new Error('Dashboard worker is not initialized.');",
      "    }",
      "    switch (message.type) {",
      "      case 'init': {",
      "        var arrow = self.Arrow;",
      "        var tableFromIPC = getTableFromIPC(arrow);",
      "        if (!tableFromIPC) {",
      "          throw new Error('Apache Arrow tableFromIPC is not available in the worker.');",
      "        }",
      "        var tableSource = null;",
      "        if (message.payload.dataUrl) {",
      "          tableSource = fetch(message.payload.dataUrl, message.payload.dataFetchInit || undefined);",
      "        } else if (message.payload.arrowBuffer) {",
      "          tableSource = new Uint8Array(message.payload.arrowBuffer);",
      "        } else {",
      "          throw new Error('Dashboard worker init requires `dataUrl` or `arrowBuffer`.');",
      "        }",
      "        var table = await tableFromIPC(tableSource);",
      "        runtime = self.crossfilter.createDashboardRuntime({",
      "          table: table,",
      "          wasm: message.payload.wasm,",
      "          dimensions: message.payload.dimensions,",
      "          groups: message.payload.groups,",
      "          kpis: message.payload.kpis",
      "        });",
      "        respond(id, { runtime: runtime.runtimeInfo() });",
      "        return;",
      "      }",
      "      case 'snapshot':",
      "        respond(id, runtime.snapshot(message.payload.filters, message.payload.options || null));",
      "        return;",
      "      case 'groups':",
      "        respond(id, runtime.groups(message.payload.request));",
      "        return;",
      "      case 'bounds':",
      "        respond(id, runtime.bounds(message.payload.request));",
      "        return;",
      "      case 'query':",
      "        respond(id, runtime.query(message.payload.request));",
      "        return;",
      "      case 'createGroup':",
      "        respond(id, runtime.createGroup(message.payload.spec));",
      "        return;",
      "      case 'disposeGroup':",
      "        respond(id, runtime.disposeGroup(message.payload.id));",
      "        return;",
      "      case 'rows':",
      "        respond(id, runtime.rows(message.payload.query));",
      "        return;",
      "      case 'rowSets':",
      "        respond(id, runtime.rowSets(message.payload.request));",
      "        return;",
      "      case 'append':",
      "        respond(id, runtime.append(message.payload.records || []));",
      "        return;",
      "      case 'removeFiltered':",
      "        respond(id, runtime.removeFiltered(message.payload.selection));",
      "        return;",
      "      case 'updateFilters':",
      "        respond(id, runtime.updateFilters(message.payload.filters));",
      "        return;",
      "      case 'reset':",
      "        respond(id, runtime.reset());",
      "        return;",
      "      case 'runtimeInfo':",
      "        respond(id, runtime.runtimeInfo());",
      "        return;",
      "      case 'dispose':",
      "        if (runtime) {",
      "          runtime.dispose();",
      "          runtime = null;",
      "        }",
      "        respond(id, null);",
      "        self.close();",
      "        return;",
      "      default:",
      "        throw new Error('Unknown dashboard worker message: ' + message.type);",
      "    }",
      "  } catch (error) {",
      "    fail(id, error);",
      "  }",
      "};"
    ].join("\n");
  }

  function createDashboardWorker(options) {
    options = options || {};

    if (!!options.arrowBuffer === !!options.dataUrl) {
      throw new Error("createDashboardWorker expects exactly one of `arrowBuffer` or `dataUrl`.");
    }

    var workerFactory = options.workerFactory,
        workerUrl = null;

    if (!workerFactory) {
      if (typeof Worker === "undefined") {
        throw new Error("Workers are not available in this environment.");
      }
      if (!options.crossfilterUrl || !(options.arrowRuntimeUrl || options.arrowUrl)) {
        throw new Error("createDashboardWorker requires `crossfilterUrl` and `arrowRuntimeUrl` unless `workerFactory` is provided.");
      }

      var resolvedCrossfilterUrl = resolveAssetUrl$1(options.crossfilterUrl),
          resolvedArrowUrl = resolveAssetUrl$1(options.arrowRuntimeUrl || options.arrowUrl);

      workerFactory = function() {
        workerUrl = URL.createObjectURL(new Blob([
          createWorkerSource$1(resolvedCrossfilterUrl, resolvedArrowUrl)
        ], { type: "text/javascript" }));
        return new Worker(workerUrl);
      };
    }

    var worker = workerFactory();
    var nextId = 1;
    var pending = new Map();
    var disposed = false;

    function cleanupWorker() {
      if (workerUrl) {
        URL.revokeObjectURL(workerUrl);
        workerUrl = null;
      }
    }

    function rejectPending(error) {
      pending.forEach(function(entry) {
        entry.reject(error);
      });
      pending.clear();
    }

    function call(type, payload, transfer) {
      if (disposed) {
        return Promise.reject(new Error("Dashboard worker has already been disposed."));
      }

      var id = nextId++;
      return new Promise(function(resolve, reject) {
        pending.set(id, { reject: reject, resolve: resolve });
        worker.postMessage({
          id: id,
          payload: payload || null,
          type: type
        }, transfer || []);
      });
    }

    worker.addEventListener("message", function(event) {
      var message = event.data || {};
      var entry = pending.get(message.id);
      if (!entry) {
        return;
      }

      pending.delete(message.id);

      if (message.ok) {
        entry.resolve(message.payload);
        return;
      }

      var error = new Error(message.error && message.error.message || "Dashboard worker request failed.");
      if (message.error && message.error.stack) {
        error.stack = message.error.stack;
      }
      entry.reject(error);
    });

    worker.addEventListener("error", function(event) {
      var error = event.error || new Error(event.message || "Dashboard worker failed.");
      rejectPending(error);
      cleanupWorker();
    });

    var transfer = [],
        payload = {
          dataFetchInit: options.dataFetchInit || null,
          dataUrl: options.dataUrl ? resolveAssetUrl$1(options.dataUrl) : null,
          dimensions: options.dimensions || [],
          groups: options.groups || [],
          kpis: options.kpis || [],
          wasm: options.wasm !== false
        };

    if (options.arrowBuffer) {
      payload.arrowBuffer = resolveArrowBuffer$1(options.arrowBuffer);
      transfer.push(payload.arrowBuffer);
    }

    return call("init", payload, transfer).then(function(initPayload) {
      return {
        append: function(records) {
          return call('append', { records: records || [] });
        },
        bounds: function(request) {
          return call("bounds", { request: request || null });
        },
        dispose: function() {
          if (disposed) {
            return Promise.resolve();
          }
          return call("dispose").catch(function(error) {
            worker.terminate();
            cleanupWorker();
            throw error;
          }).finally(function() {
            disposed = true;
            worker.terminate();
            cleanupWorker();
          });
        },
        query: function(request) {
          return call('query', { request: request || null });
        },
        createGroup: function(spec) {
          return call("createGroup", { spec: spec });
        },
        disposeGroup: function(groupId) {
          return call("disposeGroup", { id: groupId });
        },
        groups: function(request) {
          return call("groups", { request: request || null });
        },
        removeFiltered: function(selection) {
          return call('removeFiltered', { selection: selection || 'included' });
        },
        reset: function() {
          return call("reset");
        },
        runtimeInfo: function() {
          return call("runtimeInfo");
        },
        snapshot: function(filters, options) {
          return call("snapshot", {
            filters: filters || null,
            options: options || null
          });
        },
        rows: function(query) {
          return call("rows", { query: query || null });
        },
        rowSets: function(request) {
          return call("rowSets", { request: request || null });
        },
        updateFilters: function(filters) {
          return call("updateFilters", { filters: filters || null });
        },
        workerRuntime: initPayload.runtime
      };
    }).catch(function(error) {
      disposed = true;
      worker.terminate();
      cleanupWorker();
      throw error;
    });
  }

  function resolveArrowBuffer(source) {
    if (source instanceof ArrayBuffer) {
      return source;
    }

    if (ArrayBuffer.isView(source)) {
      var view = source;
      if (view.byteOffset === 0 && view.byteLength === view.buffer.byteLength) {
        return view.buffer;
      }
      return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
    }

    throw new Error("createStreamingDashboardWorker expects `arrowBuffer` to be an ArrayBuffer or typed array view.");
  }

  function resolveAssetUrl(url) {
    if (typeof URL === "function" && typeof location !== "undefined" && location && location.href) {
      return new URL(url, location.href).toString();
    }
    return url;
  }

  function normalizeStreamingSource(source, index, defaultFetchInit, transfer) {
    if (!source || typeof source !== "object") {
      throw new Error("Streaming dashboard source at index " + index + " must be an object.");
    }

    var id = source.id || "source_" + index;
    var hasArrowBuffer = source.arrowBuffer != null;
    var hasDataUrl = !!source.dataUrl;

    if (hasArrowBuffer === hasDataUrl) {
      throw new Error("Streaming dashboard source `" + id + "` expects exactly one of `arrowBuffer` or `dataUrl`.");
    }

    var normalized = {
      dataFetchInit: source.dataFetchInit || defaultFetchInit || null,
      dataUrl: source.dataUrl ? resolveAssetUrl(source.dataUrl) : null,
      id: id,
      lookup: source.lookup || null,
      projection: source.projection || null,
      role: source.role || null
    };

    if (hasArrowBuffer) {
      normalized.arrowBuffer = resolveArrowBuffer(source.arrowBuffer);
      transfer.push(normalized.arrowBuffer);
    }

    return normalized;
  }

  function resolveStreamingSources(options, transfer) {
    if (!Array.isArray(options.sources) || !options.sources.length) {
      return null;
    }

    var sources = options.sources.map(function(source, index) {
      return normalizeStreamingSource(source, index, options.dataFetchInit || null, transfer);
    });
    var baseCount = 0;

    for (var sourceIndex = 0; sourceIndex < sources.length; ++sourceIndex) {
      var source = sources[sourceIndex];
      if (!source.role) {
        source.role = sourceIndex === 0 ? "base" : "lookup";
      }
      if (source.role === "base") {
        baseCount += 1;
        if (source.lookup) {
          throw new Error("Streaming dashboard source `" + source.id + "` cannot declare `lookup` when role is `base`.");
        }
        continue;
      }
      if (source.role !== "lookup") {
        throw new Error("Streaming dashboard source `" + source.id + "` has unsupported role `" + source.role + "`.");
      }
      if (!source.lookup || !Array.isArray(source.lookup.keyFields) || !source.lookup.keyFields.length || !Array.isArray(source.lookup.valueFields) || !source.lookup.valueFields.length) {
        throw new Error("Streaming dashboard lookup source `" + source.id + "` requires non-empty `lookup.keyFields` and `lookup.valueFields`.");
      }
    }

    if (baseCount !== 1) {
      throw new Error("Streaming dashboard worker expects exactly one base source.");
    }

    return sources;
  }

  function createWorkerSource(crossfilterUrl, arrowUrl) {
    return `
'use strict';
importScripts(${JSON.stringify(crossfilterUrl)}, ${JSON.stringify(arrowUrl)});
var runtime = null;
var runtimeConfig = null;
var abortControllers = [];
var progress = null;
var progressTimer = 0;
var snapshotTimer = 0;
function getRecordBatchReader(module) {
  return module && (module.RecordBatchReader || (module.default && module.default.RecordBatchReader)) || null;
}
function getFieldNames(table) {
  if (table && table.schema && Array.isArray(table.schema.fields)) {
    return table.schema.fields.map(function(field) { return field.name; });
  }
  if (table && Array.isArray(table.columnNames)) {
    return table.columnNames.slice();
  }
  return [];
}
function getColumn(table, name, index) {
  if (!table) return undefined;
  if (typeof table.getChild === 'function') {
    var child = table.getChild(name);
    if (child != null) return child;
  }
  if (typeof table.getColumn === 'function') {
    var column = table.getColumn(name);
    if (column != null) return column;
  }
  if (typeof table.getChildAt === 'function') {
    return table.getChildAt(index);
  }
  return table[name];
}
function getValue(column, index) {
  if (column == null) return undefined;
  if (typeof column.get === 'function') return column.get(index);
  if (typeof column.at === 'function') return column.at(index);
  return column[index];
}
function resolveColumnAccessor(column) {
  if (column == null) return null;
  if (ArrayBuffer.isView(column) || Array.isArray(column)) return 'index';
  if (typeof column.get === 'function') return 'get';
  if (typeof column.at === 'function') return 'at';
  return 'index';
}
function getValueByKind(column, index, kind) {
  if (kind === 'get') return column.get(index);
  if (kind === 'at') return column.at(index);
  return column[index];
}
function allocateMergedColumn(column, length) {
  if (ArrayBuffer.isView(column) && typeof column.constructor === 'function' && typeof column.BYTES_PER_ELEMENT === 'number') {
    return new column.constructor(length);
  }
  return new Array(length);
}
function copyColumnValues(target, targetOffset, source, length) {
  if (ArrayBuffer.isView(target) && ArrayBuffer.isView(source) && source.constructor === target.constructor && typeof source.length === 'number') {
    target.set(source, targetOffset);
    return;
  }
  var sourceKind = resolveColumnAccessor(source);
  for (var rowIndex = 0; rowIndex < length; ++rowIndex) {
    target[targetOffset + rowIndex] = source == null ? undefined : getValueByKind(source, rowIndex, sourceKind);
  }
}
function mergeProjectedBatches(batches) {
  if (!batches.length) {
    return null;
  }
  if (batches.length === 1) {
    return batches[0];
  }

  var fields = batches[0].fields.slice();
  var totalLength = 0;
  var columns = {};

  for (var batchIndex = 0; batchIndex < batches.length; ++batchIndex) {
    totalLength += batches[batchIndex].length;
  }

  for (var fieldIndex = 0; fieldIndex < fields.length; ++fieldIndex) {
    columns[fields[fieldIndex]] = allocateMergedColumn(batches[0].columns[fields[fieldIndex]], totalLength);
  }

  var offset = 0;
  for (batchIndex = 0; batchIndex < batches.length; ++batchIndex) {
    var batch = batches[batchIndex];
    for (fieldIndex = 0; fieldIndex < fields.length; ++fieldIndex) {
      var field = fields[fieldIndex];
      copyColumnValues(columns[field], offset, batch.columns[field], batch.length);
    }
    offset += batch.length;
  }

  return {
    columns: columns,
    fields: fields,
    length: totalLength
  };
}
function flushBufferedRuntimeBatches(bufferedBatches) {
  if (!runtime || !bufferedBatches.length) {
    return;
  }
  var merged = mergeProjectedBatches(bufferedBatches);
  runtime.appendColumns(merged.columns, {
    fields: merged.fields,
    length: merged.length
  });
  bufferedBatches.length = 0;
}
function normalizeTimestampValue(value) {
  if (typeof value === 'string') {
    var parsed = new Date(value).getTime();
    return Number.isFinite(parsed) ? parsed : 0;
  }
  if (value instanceof Date) {
    return value.getTime();
  }
  if (typeof value === 'number') {
    return value < 1e12 ? value * 1000 : value;
  }
  var numeric = Number(value);
  if (Number.isFinite(numeric)) {
    return numeric < 1e12 ? numeric * 1000 : numeric;
  }
  return 0;
}
function collectRowTransferables(obj) {
  var buffers = [];
  if (!obj || typeof obj !== 'object' || !obj.columns) return buffers;
  for (var field in obj.columns) {
    if (Object.prototype.hasOwnProperty.call(obj.columns, field)) {
      var col = obj.columns[field];
      if (ArrayBuffer.isView(col) && col.buffer) buffers.push(col.buffer);
    }
  }
  return buffers;
}
function collectResponseTransferables(payload) {
  if (!payload || typeof payload !== 'object') return [];
  var seen = [];
  var buffers = [];
  function add(obj) {
    var found = collectRowTransferables(obj);
    for (var i = 0; i < found.length; ++i) {
      if (seen.indexOf(found[i]) < 0) {
        seen.push(found[i]);
        buffers.push(found[i]);
      }
    }
  }
  add(payload);
  if (payload.rows) add(payload.rows);
  if (payload.rowSets) {
    for (var setId in payload.rowSets) {
      if (Object.prototype.hasOwnProperty.call(payload.rowSets, setId)) {
        add(payload.rowSets[setId]);
      }
    }
  }
  return buffers;
}
function respond(id, payload) {
  var transferables = collectResponseTransferables(payload);
  self.postMessage({ id: id, ok: true, payload: payload }, transferables);
}
function fail(id, error) {
  self.postMessage({ id: id, ok: false, error: {
    message: String(error && error.message || error),
    stack: error && error.stack ? String(error.stack) : null
  } });
}
function publish(eventType, payload) {
  self.postMessage({ eventType: eventType, payload: payload });
}
function getProjectionFieldName(projection, inputName) {
  return projection && projection.rename && projection.rename[inputName] || inputName;
}
function getProjectionTransform(projection, inputName, outputName) {
  if (!projection || !projection.transforms) {
    return null;
  }
  return projection.transforms[outputName] || projection.transforms[inputName] || null;
}
function normalizeNumericValue(value) {
  if (typeof value === 'bigint') {
    return Number(value);
  }
  var numeric = Number(value);
  return Number.isFinite(numeric) ? numeric : 0;
}
function projectBatch(batch, projection) {
  var actualFields = getFieldNames(batch);
  var inputFields = projection && Array.isArray(projection.fields) && projection.fields.length
    ? projection.fields.slice()
    : actualFields.slice();
  var fieldIndexes = {};
  var projectedFields = [];
  var columns = {};
  var length = batch && typeof batch.numRows === 'number' ? batch.numRows : 0;

  for (var actualIndex = 0; actualIndex < actualFields.length; ++actualIndex) {
    fieldIndexes[actualFields[actualIndex]] = actualIndex;
  }
  if (projection && Array.isArray(projection.extraFields) && projection.extraFields.length) {
    for (var extraIndex = 0; extraIndex < projection.extraFields.length; ++extraIndex) {
      var extraField = projection.extraFields[extraIndex];
      if (inputFields.indexOf(extraField) < 0) {
        inputFields.push(extraField);
      }
    }
  }

  for (var fieldIndex = 0; fieldIndex < inputFields.length; ++fieldIndex) {
    var inputName = inputFields[fieldIndex];
    var outputName = getProjectionFieldName(projection, inputName);
    var inputIndex = Object.prototype.hasOwnProperty.call(fieldIndexes, inputName)
      ? fieldIndexes[inputName]
      : fieldIndex;
    var sourceColumn = getColumn(batch, inputName, inputIndex);
    var transform = getProjectionTransform(projection, inputName, outputName);

    if (!Object.prototype.hasOwnProperty.call(columns, outputName)) {
      projectedFields.push(outputName);
    }

    var sourceKind = resolveColumnAccessor(sourceColumn);

    if (transform === 'timestampMs') {
      var values = new Float64Array(length);
      for (var rowIndex = 0; rowIndex < length; ++rowIndex) {
        values[rowIndex] = normalizeTimestampValue(sourceColumn == null ? undefined : getValueByKind(sourceColumn, rowIndex, sourceKind));
      }
      columns[outputName] = values;
    } else if (transform === 'number') {
      values = new Float64Array(length);
      for (rowIndex = 0; rowIndex < length; ++rowIndex) {
        values[rowIndex] = normalizeNumericValue(sourceColumn == null ? undefined : getValueByKind(sourceColumn, rowIndex, sourceKind));
      }
      columns[outputName] = values;
    } else if (transform === 'constantOne') {
      values = new Float64Array(length);
      values.fill(1);
      columns[outputName] = values;
    } else {
      columns[outputName] = sourceColumn;
    }
  }

  return {
    columns: columns,
    fields: projectedFields,
    length: length
  };
}
function buildLookupKey(columns, keyFields, rowIndex) {
  if (keyFields.length === 1) {
    var value = getValue(columns[keyFields[0]], rowIndex);
    return value == null ? '' : String(value);
  }
  var parts = new Array(keyFields.length);
  for (var fieldIndex = 0; fieldIndex < keyFields.length; ++fieldIndex) {
    var value = getValue(columns[keyFields[fieldIndex]], rowIndex);
    parts[fieldIndex] = value == null ? '' : String(value);
  }
  return parts.join('|');
}
function buildLookupKeyResolved(columns, keyFields, keyKinds, rowIndex) {
  if (keyFields.length === 1) {
    var col = columns[keyFields[0]];
    var value = col == null ? undefined : getValueByKind(col, rowIndex, keyKinds[0]);
    return value == null ? '' : String(value);
  }
  var parts = new Array(keyFields.length);
  for (var fieldIndex = 0; fieldIndex < keyFields.length; ++fieldIndex) {
    var col = columns[keyFields[fieldIndex]];
    var value = col == null ? undefined : getValueByKind(col, rowIndex, keyKinds[fieldIndex]);
    parts[fieldIndex] = value == null ? '' : String(value);
  }
  return parts.join('|');
}
function createSourceProgress(source) {
  return {
    batchesLoaded: 0,
    bytesLoaded: 0,
    response: null,
    rowsLoaded: 0,
    status: 'idle',
    totalBytes: null
  };
}
function cloneSourceProgressMap(sources) {
  var clone = {};
  for (var sourceId in sources) {
    var source = sources[sourceId];
    clone[sourceId] = {
      batchesLoaded: source.batchesLoaded,
      bytesLoaded: source.bytesLoaded,
      response: source.response ? Object.assign({}, source.response) : null,
      rowsLoaded: source.rowsLoaded,
      status: source.status,
      totalBytes: source.totalBytes
    };
  }
  return clone;
}
async function readResponseErrorDetail(response) {
  if (!response || typeof response.text !== 'function') {
    return null;
  }

  try {
    var text = await response.text();
    if (!text) {
      return null;
    }
    try {
      var parsed = JSON.parse(text);
      return parsed && (parsed.error || parsed.message) ? String(parsed.error || parsed.message) : text;
    } catch (_) {
      return text;
    }
  } catch (_) {
    return null;
  }
}
function releaseAbortControllers() {
  for (var controllerIndex = 0; controllerIndex < abortControllers.length; ++controllerIndex) {
    try {
      abortControllers[controllerIndex].abort();
    } catch (_) {}
  }
  abortControllers = [];
}
function ensureRuntimeFromColumns(batchSpec) {
  if (runtime) {
    return;
  }
  runtime = self.crossfilter.createDashboardRuntime({
    columnarOptions: {
      fields: batchSpec.fields,
      length: batchSpec.length
    },
    columns: batchSpec.columns,
    wasm: runtimeConfig.wasm,
    dimensions: runtimeConfig.dimensions,
    groups: runtimeConfig.groups,
    kpis: runtimeConfig.kpis
  });
  if (runtimeConfig.initialFilters) {
    runtime.updateFilters(runtimeConfig.initialFilters);
  }
}
function ensureEmptyRuntime() {
  if (runtime) {
    return;
  }
  runtime = self.crossfilter.createDashboardRuntime({
    records: [],
    wasm: runtimeConfig.wasm,
    dimensions: runtimeConfig.dimensions,
    groups: runtimeConfig.groups,
    kpis: runtimeConfig.kpis
  });
  if (runtimeConfig.initialFilters) {
    runtime.updateFilters(runtimeConfig.initialFilters);
  }
}
function progressPayload(status, extra) {
  var sources = progress && progress.sources ? progress.sources : {};
  var batchesLoaded = 0;
  var bytesLoaded = 0;
  var rowsLoaded = 0;
  var totalBytes = 0;
  var hasKnownTotals = true;
  var hasSources = false;
  var baseRuntimeInfo = self.crossfilter.runtimeInfo();
  var payload = {
    batchesLoaded: 0,
    bytesLoaded: 0,
    fetch: {
      bytesLoaded: 0,
      totalBytes: null,
      percent: null,
      complete: false
    },
    load: {
      batchesLoaded: 0,
      rowsLoaded: 0,
      complete: !!(progress && progress.ready)
    },
    rowsLoaded: 0,
    runtime: runtime ? runtime.runtimeInfo() : {
      active: 'js',
      lastError: baseRuntimeInfo.lastError,
      wasmEnabled: runtimeConfig ? runtimeConfig.wasm !== false : baseRuntimeInfo.wasmEnabled,
      wasmSupported: baseRuntimeInfo.wasmSupported
    },
    sources: cloneSourceProgressMap(sources),
    status: status,
    totalBytes: null
  };

  for (var sourceId in sources) {
    var source = sources[sourceId];
    hasSources = true;
    batchesLoaded += source.batchesLoaded || 0;
    bytesLoaded += source.bytesLoaded || 0;
    rowsLoaded += source.rowsLoaded || 0;
    if (source.totalBytes == null) {
      hasKnownTotals = false;
    } else {
      totalBytes += source.totalBytes;
    }
  }

  payload.batchesLoaded = batchesLoaded;
  payload.bytesLoaded = bytesLoaded;
  payload.rowsLoaded = rowsLoaded;
  payload.load = {
    batchesLoaded: batchesLoaded,
    rowsLoaded: rowsLoaded,
    complete: !!(progress && progress.ready)
  };
  payload.totalBytes = hasSources && hasKnownTotals ? totalBytes : null;
  payload.fetch = {
    bytesLoaded: bytesLoaded,
    totalBytes: payload.totalBytes,
    percent: payload.totalBytes > 0 ? Math.min(1, bytesLoaded / payload.totalBytes) : null,
    complete: status === 'ready' || status === 'aborted' || status === 'error' || (payload.totalBytes != null && bytesLoaded >= payload.totalBytes)
  };

  if (extra) {
    for (var key in extra) {
      payload[key] = extra[key];
    }
  }

  return payload;
}
function publishProgress(status, force, extra) {
  var now = Date.now();
  if (!force && progress && progress.progressThrottleMs > 0 && now - progressTimer < progress.progressThrottleMs) {
    return;
  }
  progressTimer = now;
  publish('progress', progressPayload(status, extra));
}
async function* responseChunks(sourceId, response) {
  var sourceProgress = progress.sources[sourceId];
  if (!response.body || typeof response.body.getReader !== 'function') {
    var buffer = await response.arrayBuffer();
    sourceProgress.bytesLoaded = buffer.byteLength;
    sourceProgress.status = 'downloading';
    publishProgress('downloading', true);
    yield new Uint8Array(buffer);
    return;
  }
  var reader = response.body.getReader();
  try {
    while (true) {
      var chunk = await reader.read();
      if (chunk.done) {
        return;
      }
      var value = chunk.value;
      sourceProgress.bytesLoaded += value.byteLength || value.length || 0;
      sourceProgress.status = 'downloading';
      publishProgress('downloading', false);
      yield value;
    }
  } finally {
    if (reader.releaseLock) reader.releaseLock();
  }
}
async function getSourceInput(source) {
  var sourceProgress = progress.sources[source.id];
  if (source.dataUrl) {
    sourceProgress.status = 'requesting';
    publishProgress('starting', true);
    var controller = typeof AbortController === 'function' ? new AbortController() : null;
    var fetchInit = source.dataFetchInit || {};
    if (controller) {
      fetchInit = Object.assign({}, fetchInit, { signal: controller.signal });
      abortControllers.push(controller);
    }
    var response = await fetch(source.dataUrl, fetchInit);
    if (!response.ok) {
      var responseErrorDetail = await readResponseErrorDetail(response);
      throw new Error('Failed to fetch Arrow stream for ' + source.id + ': ' + response.status + ' ' + response.statusText + (responseErrorDetail ? ' — ' + responseErrorDetail : ''));
    }
    var headerValue = response.headers && response.headers.get ? response.headers.get('content-length') : null;
    sourceProgress.response = response.headers && response.headers.get ? {
      arrowFieldMapping: response.headers.get('x-synmetrix-arrow-field-mapping') || null,
      arrowFieldMappingEncoding: response.headers.get('x-synmetrix-arrow-field-mapping-encoding') || null,
      contentDisposition: response.headers.get('content-disposition') || null,
      contentType: response.headers.get('content-type') || null
    } : null;
    sourceProgress.totalBytes = headerValue == null ? null : Number(headerValue);
    sourceProgress.status = 'downloading';
    publishProgress('downloading', true);
    return responseChunks(source.id, response);
  }
  sourceProgress.totalBytes = source.arrowBuffer.byteLength || null;
  sourceProgress.bytesLoaded = sourceProgress.totalBytes || 0;
  sourceProgress.status = 'downloading';
  publishProgress('downloading', true);
  return new Uint8Array(source.arrowBuffer);
}
async function maybePublishSnapshot(force) {
  if (!progress || !progress.emitSnapshots || !runtime) {
    return;
  }
  var now = Date.now();
  if (!force && progress.snapshotThrottleMs > 0 && now - snapshotTimer < progress.snapshotThrottleMs) {
    return;
  }
  snapshotTimer = now;
  publish('snapshot', {
    progress: progressPayload(progress.ready ? 'ready' : 'streaming'),
    snapshot: runtime.snapshot(null, runtimeConfig && runtimeConfig.snapshotGroups ? { groups: runtimeConfig.snapshotGroups } : null)
  });
}
async function streamBaseSourceIntoRuntime(source) {
  var arrow = self.Arrow;
  var RecordBatchReader = getRecordBatchReader(arrow);
  var sourceProgress = progress.sources[source.id];
  var reader = await RecordBatchReader.from(await getSourceInput(source));
  var bufferedBatches = [];
  var bufferedRows = 0;

  for await (var batch of reader) {
    var projected = projectBatch(batch, source.projection);
    if (!runtime) {
      ensureRuntimeFromColumns(projected);
    } else {
      bufferedBatches.push(projected);
      bufferedRows += projected.length;
      if (bufferedRows >= runtimeConfig.batchCoalesceRows) {
        flushBufferedRuntimeBatches(bufferedBatches);
        bufferedRows = 0;
      }
    }
    sourceProgress.batchesLoaded += 1;
    sourceProgress.rowsLoaded += projected.length;
    sourceProgress.status = 'streaming';
    publishProgress('streaming', false);
    if (progress.emitSnapshots && bufferedBatches.length) {
      var shouldFlushForSnapshot = progress.snapshotThrottleMs <= 0 || Date.now() - snapshotTimer >= progress.snapshotThrottleMs;
      if (shouldFlushForSnapshot) {
        flushBufferedRuntimeBatches(bufferedBatches);
        bufferedRows = 0;
      }
    }
    await maybePublishSnapshot(false);
  }

  if (bufferedBatches.length) {
    flushBufferedRuntimeBatches(bufferedBatches);
  }

  sourceProgress.status = 'ready';
  publishProgress('streaming', true);
}
async function loadProjectedBatchesFromSource(source) {
  var arrow = self.Arrow;
  var RecordBatchReader = getRecordBatchReader(arrow);
  var sourceProgress = progress.sources[source.id];
  var reader = await RecordBatchReader.from(await getSourceInput(source));
  var batches = [];
  var fields = [];
  var rowCount = 0;

  for await (var batch of reader) {
    var projected = projectBatch(batch, source.projection);
    batches.push(projected);
    if (!fields.length) {
      fields = projected.fields.slice();
    }
    rowCount += projected.length;
    sourceProgress.batchesLoaded += 1;
    sourceProgress.rowsLoaded += projected.length;
    sourceProgress.status = 'streaming';
    publishProgress('streaming', false);
  }

  sourceProgress.status = 'ready';
  publishProgress('streaming', true);
  return {
    batches: batches,
    fields: fields,
    rowCount: rowCount,
    sourceId: source.id
  };
}
async function buildLookupIndexFromSource(source) {
  var arrow = self.Arrow;
  var RecordBatchReader = getRecordBatchReader(arrow);
  var sourceProgress = progress.sources[source.id];
  var reader = await RecordBatchReader.from(await getSourceInput(source));
  var index = new Map();
  var valueFields = source.lookup.valueFields.slice();
  var valueKinds = new Array(valueFields.length);

  for await (var batch of reader) {
    var projected = projectBatch(batch, source.projection);
    var keyKinds = new Array(source.lookup.keyFields.length);
    for (var ki = 0; ki < source.lookup.keyFields.length; ++ki) {
      keyKinds[ki] = resolveColumnAccessor(projected.columns[source.lookup.keyFields[ki]]);
    }
    var valKinds = new Array(valueFields.length);
    for (var vi = 0; vi < valueFields.length; ++vi) {
      valKinds[vi] = resolveColumnAccessor(projected.columns[valueFields[vi]]);
    }

    for (var rowIndex = 0; rowIndex < projected.length; ++rowIndex) {
      var key = buildLookupKeyResolved(projected.columns, source.lookup.keyFields, keyKinds, rowIndex);
      if (index.has(key)) {
        continue;
      }
      var values = new Array(valueFields.length);
      for (var valueIndex = 0; valueIndex < valueFields.length; ++valueIndex) {
        var valCol = projected.columns[valueFields[valueIndex]];
        var fieldValue = valCol == null ? undefined : getValueByKind(valCol, rowIndex, valKinds[valueIndex]);
        values[valueIndex] = fieldValue;
        if (valueKinds[valueIndex] !== 'generic' && typeof fieldValue === 'number' && Number.isFinite(fieldValue)) {
          valueKinds[valueIndex] = 'number';
        } else if (fieldValue != null && (typeof fieldValue !== 'number' || !Number.isFinite(fieldValue))) {
          valueKinds[valueIndex] = 'generic';
        }
      }
      index.set(key, values);
    }

    sourceProgress.batchesLoaded += 1;
    sourceProgress.rowsLoaded += projected.length;
    sourceProgress.status = 'streaming';
    publishProgress('streaming', false);
  }

  sourceProgress.status = 'ready';
  publishProgress('streaming', true);
  return {
    id: source.id,
    index: index,
    keyFields: source.lookup.keyFields.slice(),
    valueFields: valueFields,
    valueKinds: valueKinds.map(function(kind) {
      return kind === 'number' ? 'number' : 'generic';
    })
  };
}
function allocateLookupColumn(length, kind) {
  if (kind === 'number') {
    var numeric = new Float64Array(length);
    numeric.fill(NaN);
    return numeric;
  }
  return new Array(length);
}
function applyLookupIndexes(baseBatches, lookupResults) {
  for (var batchIndex = 0; batchIndex < baseBatches.length; ++batchIndex) {
    var batch = baseBatches[batchIndex];

    for (var lookupIndex = 0; lookupIndex < lookupResults.length; ++lookupIndex) {
      var lookup = lookupResults[lookupIndex];
      var columnsByField = {};

      for (var valueFieldIndex = 0; valueFieldIndex < lookup.valueFields.length; ++valueFieldIndex) {
        var valueField = lookup.valueFields[valueFieldIndex];
        columnsByField[valueField] = allocateLookupColumn(batch.length, lookup.valueKinds[valueFieldIndex]);
        if (batch.fields.indexOf(valueField) < 0) {
          batch.fields.push(valueField);
        }
      }

      var lookupKeyKinds = new Array(lookup.keyFields.length);
      for (var ki = 0; ki < lookup.keyFields.length; ++ki) {
        lookupKeyKinds[ki] = resolveColumnAccessor(batch.columns[lookup.keyFields[ki]]);
      }

      for (var rowIndex = 0; rowIndex < batch.length; ++rowIndex) {
        var values = lookup.index.get(buildLookupKeyResolved(batch.columns, lookup.keyFields, lookupKeyKinds, rowIndex));
        if (!values) {
          continue;
        }
        for (var fieldIndex = 0; fieldIndex < lookup.valueFields.length; ++fieldIndex) {
          columnsByField[lookup.valueFields[fieldIndex]][rowIndex] = values[fieldIndex];
        }
      }

      for (fieldIndex = 0; fieldIndex < lookup.valueFields.length; ++fieldIndex) {
        batch.columns[lookup.valueFields[fieldIndex]] = columnsByField[lookup.valueFields[fieldIndex]];
      }
    }
  }
}
function buildRuntimeFromBatches(batches) {
  if (!batches.length) {
    ensureEmptyRuntime();
    return;
  }

  ensureRuntimeFromColumns(batches[0]);
  if (batches.length === 1) {
    return;
  }

  var bufferedBatches = [];
  var bufferedRows = 0;

  for (var batchIndex = 1; batchIndex < batches.length; ++batchIndex) {
    bufferedBatches.push(batches[batchIndex]);
    bufferedRows += batches[batchIndex].length;
    if (bufferedRows >= runtimeConfig.batchCoalesceRows) {
      flushBufferedRuntimeBatches(bufferedBatches);
      bufferedRows = 0;
    }
  }

  if (bufferedBatches.length) {
    flushBufferedRuntimeBatches(bufferedBatches);
  }
}
async function startStreaming(payload) {
  var arrow = self.Arrow;
  var RecordBatchReader = getRecordBatchReader(arrow);
  if (!RecordBatchReader || !RecordBatchReader.from) {
    throw new Error('Apache Arrow RecordBatchReader is not available in the worker.');
  }

  var sources = payload.sources && payload.sources.length
    ? payload.sources.slice()
    : [{
        arrowBuffer: payload.arrowBuffer || null,
        dataFetchInit: payload.dataFetchInit || null,
        dataUrl: payload.dataUrl || null,
        id: 'source_0',
        lookup: null,
        projection: null,
        role: 'base'
      }];

  progress = {
    emitSnapshots: payload.emitSnapshots === true,
    progressThrottleMs: typeof payload.progressThrottleMs === 'number' ? payload.progressThrottleMs : 100,
    ready: false,
    snapshotThrottleMs: typeof payload.snapshotThrottleMs === 'number' ? payload.snapshotThrottleMs : 250,
    sources: {}
  };

  progressTimer = 0;
  snapshotTimer = 0;
  abortControllers = [];

  for (var sourceIndex = 0; sourceIndex < sources.length; ++sourceIndex) {
    progress.sources[sources[sourceIndex].id] = createSourceProgress(sources[sourceIndex]);
  }

  publishProgress('starting', true);

  try {
    if (sources.length === 1 && sources[0].role === 'base') {
      await streamBaseSourceIntoRuntime(sources[0]);
    } else {
      var baseSource = null;
      var lookupSources = [];

      for (sourceIndex = 0; sourceIndex < sources.length; ++sourceIndex) {
        if (sources[sourceIndex].role === 'base') {
          baseSource = sources[sourceIndex];
        } else {
          lookupSources.push(sources[sourceIndex]);
        }
      }

      var results = await Promise.all([loadProjectedBatchesFromSource(baseSource)].concat(lookupSources.map(function(source) {
        return buildLookupIndexFromSource(source);
      })));
      var baseResult = results[0];
      var lookupResults = results.slice(1);

      publishProgress('joining', true);
      applyLookupIndexes(baseResult.batches, lookupResults);
      publishProgress('building', true);
      buildRuntimeFromBatches(baseResult.batches);
    }

    ensureEmptyRuntime();
    progress.ready = true;
    publishProgress('ready', true);
    await maybePublishSnapshot(true);
    publish('ready', progressPayload('ready'));
  } catch (error) {
    if (error && error.name === 'AbortError') {
      publishProgress('aborted', true);
      return;
    }
    publish('error', Object.assign(progressPayload('error'), {
      message: String(error && error.message || error),
      stack: error && error.stack ? String(error.stack) : null
    }));
  }
}
self.onmessage = async function(event) {
  var message = event.data || {};
  var id = message.id;
  try {
    if (message.type !== 'initStreaming' && message.type !== 'dispose') {
      if (!runtime) throw new Error('Streaming dashboard worker is not initialized.');
    }
    switch (message.type) {
      case 'initStreaming': {
        runtimeConfig = {
          batchCoalesceRows: typeof message.payload.batchCoalesceRows === 'number' && message.payload.batchCoalesceRows > 0
            ? Math.floor(message.payload.batchCoalesceRows)
            : 65536,
          wasm: message.payload.wasm,
          dimensions: message.payload.dimensions,
          groups: message.payload.groups,
          kpis: message.payload.kpis,
          initialFilters: message.payload.initialFilters || null,
          snapshotGroups: message.payload.snapshotGroups || null
        };
        runtime = null;
        startStreaming(message.payload);
        respond(id, { runtime: null });
        return;
      }
      case 'snapshot':
        respond(id, runtime.snapshot(message.payload.filters, message.payload.options || null));
        return;
      case 'groups':
        respond(id, runtime.groups(message.payload.request));
        return;
      case 'bounds':
        respond(id, runtime.bounds(message.payload.request));
        return;
      case 'query':
        respond(id, runtime.query(message.payload.request));
        return;
      case 'append':
        respond(id, runtime.append(message.payload.records || []));
        return;
      case 'updateFilters':
        respond(id, runtime.updateFilters(message.payload.filters));
        return;
      case 'createGroup':
        respond(id, runtime.createGroup(message.payload.spec));
        return;
      case 'disposeGroup':
        respond(id, runtime.disposeGroup(message.payload.id));
        return;
      case 'rows':
        respond(id, runtime.rows(message.payload.query));
        return;
      case 'rowSets':
        respond(id, runtime.rowSets(message.payload.request));
        return;
      case 'removeFiltered':
        respond(id, runtime.removeFiltered(message.payload.selection));
        return;
      case 'reset':
        respond(id, runtime.reset());
        return;
      case 'runtimeInfo':
        respond(id, runtime.runtimeInfo());
        return;
      case 'dispose':
        releaseAbortControllers();
        if (runtime) {
          runtime.dispose();
          runtime = null;
        }
        runtimeConfig = null;
        respond(id, null);
        self.close();
        return;
      default:
        throw new Error('Unknown streaming dashboard worker message: ' + message.type);
    }
  } catch (error) {
    fail(id, error);
  }
};
`;
  }

  function createStreamingDashboardWorker(options) {
    options = options || {};

    var hasSources = Array.isArray(options.sources) && options.sources.length > 0;
    var modeCount = (options.arrowBuffer ? 1 : 0) + (options.dataUrl ? 1 : 0) + (hasSources ? 1 : 0);

    if (modeCount !== 1) {
      throw new Error("createStreamingDashboardWorker expects exactly one of `arrowBuffer`, `dataUrl` or `sources`.");
    }

    var workerFactory = options.workerFactory,
        workerUrl = null;

    if (!workerFactory) {
      if (typeof Worker === "undefined") {
        throw new Error("Workers are not available in this environment.");
      }
      if (!options.crossfilterUrl || !(options.arrowRuntimeUrl || options.arrowUrl)) {
        throw new Error("createStreamingDashboardWorker requires `crossfilterUrl` and `arrowRuntimeUrl` unless `workerFactory` is provided.");
      }

      var resolvedCrossfilterUrl = resolveAssetUrl(options.crossfilterUrl),
          resolvedArrowUrl = resolveAssetUrl(options.arrowRuntimeUrl || options.arrowUrl);

      workerFactory = function() {
        workerUrl = URL.createObjectURL(new Blob([
          createWorkerSource(resolvedCrossfilterUrl, resolvedArrowUrl)
        ], { type: "text/javascript" }));
        return new Worker(workerUrl);
      };
    }

    var worker = workerFactory();
    var nextId = 1;
    var pending = new Map();
    var listeners = {
      error: new Set(),
      progress: new Set(),
      ready: new Set(),
      snapshot: new Set()
    };
    var disposed = false;
    var readyResolve;
    var readyReject;
    var ready = new Promise(function(resolve, reject) {
      readyResolve = resolve;
      readyReject = reject;
    });

    function cleanupWorker() {
      if (workerUrl) {
        URL.revokeObjectURL(workerUrl);
        workerUrl = null;
      }
    }

    function rejectPending(error) {
      pending.forEach(function(entry) {
        entry.reject(error);
      });
      pending.clear();
    }

    function emit(eventType, payload) {
      listeners[eventType].forEach(function(listener) {
        listener(payload);
      });
    }

    function call(type, payload, transfer) {
      if (disposed) {
        return Promise.reject(new Error("Streaming dashboard worker has already been disposed."));
      }

      var id = nextId++;
      return new Promise(function(resolve, reject) {
        pending.set(id, { resolve: resolve, reject: reject });
        worker.postMessage({
          id: id,
          payload: payload || null,
          type: type
        }, transfer || []);
      });
    }

    worker.addEventListener("message", function(event) {
      var message = event.data || {};

      if (message.eventType) {
        emit(message.eventType, message.payload);
        if (message.eventType === "ready") {
          readyResolve(message.payload);
        } else if (message.eventType === "error") {
          readyReject(new Error(message.payload && message.payload.message || "Streaming dashboard worker failed."));
        }
        return;
      }

      var entry = pending.get(message.id);
      if (!entry) {
        return;
      }

      pending.delete(message.id);

      if (message.ok) {
        entry.resolve(message.payload);
        return;
      }

      var error = new Error(message.error && message.error.message || "Streaming dashboard worker request failed.");
      if (message.error && message.error.stack) {
        error.stack = message.error.stack;
      }
      entry.reject(error);
    });

    worker.addEventListener("error", function(event) {
      var error = event.error || new Error(event.message || "Streaming dashboard worker failed.");
      rejectPending(error);
      readyReject(error);
      cleanupWorker();
    });

    var transfer = [];
    var sources = resolveStreamingSources(options, transfer);
    var payload = {
      dataFetchInit: options.dataFetchInit || null,
      dataUrl: sources ? null : options.dataUrl ? resolveAssetUrl(options.dataUrl) : null,
      dimensions: options.dimensions || [],
      emitSnapshots: options.emitSnapshots === true,
      groups: options.groups || [],
      initialFilters: options.initialFilters || null,
      kpis: options.kpis || [],
      progressThrottleMs: options.progressThrottleMs,
      snapshotGroups: options.snapshotGroups || null,
      snapshotThrottleMs: options.snapshotThrottleMs,
      sources: sources,
      batchCoalesceRows: options.batchCoalesceRows,
      wasm: options.wasm !== false
    };

    if (!sources && options.arrowBuffer) {
      payload.arrowBuffer = resolveArrowBuffer(options.arrowBuffer);
      transfer.push(payload.arrowBuffer);
    }

    return call("initStreaming", payload, transfer).then(function(initPayload) {
      return {
        append: function(records) {
          return call('append', { records: records || [] });
        },
        bounds: function(request) {
          return call("bounds", { request: request || null });
        },
        dispose: function() {
          if (disposed) {
            return Promise.resolve();
          }
          return call("dispose").catch(function(error) {
            worker.terminate();
            cleanupWorker();
            throw error;
          }).finally(function() {
            disposed = true;
            worker.terminate();
            cleanupWorker();
          });
        },
        on: function(eventType, listener) {
          if (!listeners[eventType]) {
            throw new Error("Unsupported streaming dashboard event: " + eventType);
          }
          listeners[eventType].add(listener);
          return function() {
            listeners[eventType].delete(listener);
          };
        },
        ready: ready,
        query: function(request) {
          return call('query', { request: request || null });
        },
        groups: function(request) {
          return call("groups", { request: request || null });
        },
        removeFiltered: function(selection) {
          return call('removeFiltered', { selection: selection || 'included' });
        },
        reset: function() {
          return call("reset");
        },
        runtimeInfo: function() {
          return call("runtimeInfo");
        },
        snapshot: function(filters, options) {
          return call("snapshot", {
            filters: filters || null,
            options: options || null
          });
        },
        rows: function(query) {
          return call("rows", { query: query || null });
        },
        rowSets: function(request) {
          return call("rowSets", { request: request || null });
        },
        updateFilters: function(filters) {
          return call("updateFilters", { filters: filters || null });
        },
        createGroup: function(spec) {
          return call("createGroup", { spec: spec });
        },
        disposeGroup: function(groupId) {
          return call("disposeGroup", { id: groupId });
        },
        workerRuntime: initPayload.runtime
      };
    }).catch(function(error) {
      disposed = true;
      worker.terminate();
      cleanupWorker();
      throw error;
    });
  }

  // constants
  var REMOVED_INDEX = -1;

  crossfilter.heap = h$1;
  crossfilter.heapselect = h;
  crossfilter.bisect = bisect;
  crossfilter.permute = permute;
  crossfilter.rowsFromColumns = rowsFromColumns;
  crossfilter.fromColumns = function(columns, options) {
    return crossfilter(rowsFromColumns(columns, options));
  };
  crossfilter.rowsFromArrowTable = rowsFromArrowTable;
  crossfilter.fromArrowTable = function(table, options) {
    return crossfilter(rowsFromArrowTable(table, options));
  };
  crossfilter.configureRuntime = configureWasmRuntime;
  crossfilter.runtimeInfo = getWasmRuntimeInfo;
  crossfilter.createDashboardRuntime = function(options) {
    return createDashboardRuntime(crossfilter, options);
  };
  crossfilter.createDashboardWorker = function(options) {
    return createDashboardWorker(options);
  };
  crossfilter.createStreamingDashboardWorker = function(options) {
    return createStreamingDashboardWorker(options);
  };
  // Match simple property access patterns in function source:
  //   d => d.prop, (d) => d['prop'], function(d) { return d.prop; }
  var re_arrowAccessor = /^\(?(\w+)\)?\s*=>\s*\1(?:\.(\w+)|\[['"]([^'"]+)['"]\])\s*$/;
  var re_functionAccessor = /^function\s*\w*\s*\(\s*(\w+)\s*\)\s*\{\s*return\s+\1(?:\.(\w+)|\[['"]([^'"]+)['"]\])\s*;?\s*\}$/;

  function tryExtractAccessorPath(fn) {
    try {
      var source = fn.toString().trim();
      var match = re_arrowAccessor.exec(source) || re_functionAccessor.exec(source);
      return match ? (match[2] || match[3]) : null;
    } catch (e) {
      return null;
    }
  }

  function crossfilter() {
    var runtimeController = createWasmRuntimeController();
    var crossfilter = {
      add: add,
      allFilteredIndexes: allFilteredIndexes,
      batch: batch,
      remove: removeData,
      dimension: dimension,
      getFieldValue: getFieldValue,
      groupAll: groupAll,
      size: size,
      all: all,
      allFiltered: allFiltered,
      onChange: onChange,
      isElementFiltered: isElementFiltered,
      takeColumns: takeColumns,
      configureRuntime: runtimeController.configureRuntime,
      runtimeInfo: runtimeController.runtimeInfo
    };

    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
        resetListeners = [],
        callbacks = [],
        columnarBatches = [],
        activeDimensionFilterCount = 0,
        batchedFilterDepth = 0,
        batchedFilterEventPending = false,
        batchedFilterResetPending = false;

    filters = new xfilterArray.bitarray(0);

    function appendData(newData) {
      var offset = data.length;
      data.length = offset + newData.length;
      var batch = getColumnarBatch(newData);
      if (batch) {
        for (var key in batch.rows) {
          if (Object.prototype.hasOwnProperty.call(batch.rows, key)) {
            data[offset + Number(key)] = batch.rows[key];
          }
        }
        return;
      }
      for (var i = 0; i < newData.length; ++i) {
        data[offset + i] = newData[i];
      }
    }

    function rememberColumnarBatch(newData, n0, n1) {
      var batch = getColumnarBatch(newData);
      if (!batch) {
        return;
      }

      columnarBatches.push({
        batch: batch,
        accessors: batch.accessorsByField,
        columns: batch.columns,
        start: n0,
        end: n0 + n1
      });
    }

    function findColumnarBatch(rowIndex) {
      if (columnarBatches.length === 1) {
        var onlyBatch = columnarBatches[0];
        return rowIndex >= onlyBatch.start && rowIndex < onlyBatch.end
          ? onlyBatch
          : null;
      }

      var lo = 0,
          hi = columnarBatches.length;

      while (lo < hi) {
        var mid = lo + hi >>> 1,
            batch = columnarBatches[mid];
        if (rowIndex < batch.start) hi = mid;
        else if (rowIndex >= batch.end) lo = mid + 1;
        else return batch;
      }

      return null;
    }

    function hasAnyActiveDimensionFilters() {
      return activeDimensionFilterCount > 0;
    }

    function registerResetListener(listener) {
      resetListeners.push(listener);
      return listener;
    }

    function unregisterResetListener(listener) {
      var listenerIndex = resetListeners.indexOf(listener);
      if (listenerIndex >= 0) {
        resetListeners.splice(listenerIndex, 1);
      }
    }

    function markFilterListenersDirty() {
      if (batchedFilterResetPending) {
        return;
      }
      batchedFilterResetPending = true;
      for (var listenerIndex = 0; listenerIndex < resetListeners.length; ++listenerIndex) {
        resetListeners[listenerIndex]();
      }
    }

    function notifyFilterListeners(filterOne, filterOffset, added, removed) {
      if (batchedFilterDepth > 0) {
        batchedFilterEventPending = true;
        markFilterListenersDirty();
        return;
      }

      filterListeners.forEach(function(l) { l(filterOne, filterOffset, added, removed); });
      triggerOnChange('filtered');
    }

    function flushBatchedFilterEvents() {
      if (!batchedFilterEventPending) {
        return;
      }
      batchedFilterEventPending = false;
      batchedFilterResetPending = false;
      triggerOnChange('filtered');
    }

    function batch(callback) {
      batchedFilterDepth += 1;
      try {
        return callback();
      } finally {
        batchedFilterDepth -= 1;
        if (!batchedFilterDepth) {
          flushBatchedFilterEvents();
        }
      }
    }

    function getRecord(rowIndex) {
      var row = data[rowIndex];
      if (row !== undefined) {
        return row;
      }

      if (!columnarBatches.length) {
        return rowIndex in data ? row : undefined;
      }

      var batch = findColumnarBatch(rowIndex);
      if (!batch) {
        return rowIndex in data ? row : undefined;
      }

      var batchRowIndex = rowIndex - batch.start;
      if (batch.batch.materialized && batch.batch.materialized[batchRowIndex]) {
        row = batch.batch.rows[batchRowIndex];
      } else {
        row = materializeColumnarRow(batch.batch, batchRowIndex);
      }
      data[rowIndex] = row;
      return row;
    }

    function getFieldValue(rowIndex, field) {
      var row = data[rowIndex];
      if (row !== undefined) {
        return row ? row[field] : undefined;
      }

      if (columnarBatches.length) {
        var batch = findColumnarBatch(rowIndex);
        if (batch) {
          var batchRowIndex = rowIndex - batch.start;
          if (batch.accessors && batch.accessors[field]) {
            return batch.accessors[field](batchRowIndex);
          }
          if (Object.prototype.hasOwnProperty.call(batch.columns, field)) {
            return getColumnValue(batch.columns[field], batchRowIndex);
          }
        }
      }

      row = getRecord(rowIndex);
      return row ? row[field] : undefined;
    }

    function isFiniteMetricNumber(value) {
      return typeof value === 'number' && Number.isFinite(value);
    }

    function resolveReduceMetricSpec(add, remove, initial) {
      var metricSpec = add && add._xfilterMetricSpec;
      if (!metricSpec || metricSpec !== (remove && remove._xfilterMetricSpec) || metricSpec !== (initial && initial._xfilterMetricSpec)) {
        return null;
      }
      return metricSpec;
    }

    function applyReduceMetricSpec(state, metricSpec, rowIndex, delta) {
      if (!state) {
        return state;
      }

      for (var metricIndex = 0; metricIndex < metricSpec.length; ++metricIndex) {
        var metric = metricSpec[metricIndex];
        var value;

        switch (metric.op) {
          case 'count':
            state[metric.id] += delta;
            break;
          case 'sum':
            value = getFieldValue(rowIndex, metric.field);
            if (isFiniteMetricNumber(value)) {
              state[metric.id] += delta * value;
            }
            break;
          case 'avg':
            value = getFieldValue(rowIndex, metric.field);
            if (isFiniteMetricNumber(value)) {
              state[metric.id].sum += delta * value;
              state[metric.id].count += delta;
            }
            break;
          case 'avgNonZero':
            value = getFieldValue(rowIndex, metric.field);
            if (isFiniteMetricNumber(value) && value !== 0) {
              state[metric.id].sum += delta * value;
              state[metric.id].count += delta;
            }
            break;
        }
      }

      state.__version += 1;
      return state;
    }

    function materializeAllRecords() {
      if (!columnarBatches.length) {
        return;
      }
      for (var rowIndex = 0; rowIndex < n; ++rowIndex) {
        getRecord(rowIndex);
      }
    }

    function copyFieldValuesFromRows(target, targetOffset, field, start, end) {
      for (var i = start; i < end; ++i) {
        target[targetOffset++] = getRecord(i)[field];
      }
      return targetOffset;
    }

    function extractColumnValues(field, start, count) {
      if (!count) {
        return [];
      }

      var values = new Array(count),
          cursor = start,
          targetOffset = 0,
          end = start + count;

      if (!columnarBatches.length) {
        copyFieldValuesFromRows(values, 0, field, start, end);
        return values;
      }

      for (var batchIndex = 0; batchIndex < columnarBatches.length && cursor < end; ++batchIndex) {
        var batch = columnarBatches[batchIndex];

        if (batch.end <= cursor) {
          continue;
        }

        if (batch.start >= end) {
          break;
        }

        if (cursor < batch.start) {
          var gapEnd = Math.min(batch.start, end);
          targetOffset = copyFieldValuesFromRows(values, targetOffset, field, cursor, gapEnd);
          cursor = gapEnd;
          if (cursor >= end) {
            break;
          }
        }

        var segmentStart = Math.max(cursor, batch.start),
            segmentEnd = Math.min(batch.end, end),
            accessor = batch.accessors && batch.accessors[field],
            column = batch.columns[field];

        if (accessor) {
          for (var valueIndex = segmentStart; valueIndex < segmentEnd; ++valueIndex) {
            values[targetOffset++] = accessor(valueIndex - batch.start);
          }
        } else if (column != null) {
          for (var valueIndex = segmentStart; valueIndex < segmentEnd; ++valueIndex) {
            values[targetOffset++] = getColumnValue(column, valueIndex - batch.start);
          }
        } else {
          targetOffset = copyFieldValuesFromRows(values, targetOffset, field, segmentStart, segmentEnd);
        }

        cursor = segmentEnd;
      }

      if (cursor < end) {
        copyFieldValuesFromRows(values, targetOffset, field, cursor, end);
      }

      return values;
    }

    function findSingleColumnAccessorSegment(field, start, count) {
      if (!count || !columnarBatches.length) {
        return null;
      }

      var end = start + count;

      for (var batchIndex = 0; batchIndex < columnarBatches.length; ++batchIndex) {
        var batch = columnarBatches[batchIndex];

        if (batch.end <= start) {
          continue;
        }

        if (batch.start > start) {
          return null;
        }

        if (batch.end < end) {
          return null;
        }

        if (!batch.accessors || !batch.accessors[field]) {
          return null;
        }

        return {
          accessor: batch.accessors[field],
          offset: start - batch.start
        };
      }

      return null;
    }

    // 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) {
        appendData(newData);
        rememberColumnarBatch(newData, n0, n1);
        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) {
      materializeAllRecords();
      var // Mapping from old record indexes to new indexes (after records removed)
          newIndex = new Array(n),
          removed = [],
          usePred = typeof predicate === 'function',
          shouldRemove = function (i) {
            return usePred ? predicate(getRecord(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);
      columnarBatches = [];
      triggerOnChange('dataRemoved');
    }

    function maskForDimensions(dimensions) {
      var n,
          d,
          len,
          id,
          mask = Array(filters.subarrays);
      for (n = 0; n < filters.subarrays; n++) { mask[n] = ~0; }
      for (d = 0, len = 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 = dimensions[d].id();
        mask[id >> 7] &= ~(0x1 << (id & 0x3f));
      }
      return mask;
    }

    // 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 mask = maskForDimensions(ignore_dimensions || []);
      return filters.zeroExceptMask(i,mask);
    }

    // Adds a new dimension with the specified value accessor function.
    function dimension(value, iterable) {
      var accessorPath;

      if (typeof value === 'string') {
        accessorPath = value;
        value = function(d) { return result(d, accessorPath); };
      } else if (typeof value === 'function') {
        accessorPath = tryExtractAccessorPath(value);
      }

      var dimension = {
        filter: filter,
        filterExact: filterExact,
        filterIn: filterIn,
        filterRange: filterRange,
        filterFunction: filterFunction,
        filterAll: filterAll,
        currentFilter: currentFilter,
        hasCurrentFilter: hasCurrentFilter,
        top: top,
        topIndex: topIndex,
        bottom: bottom,
        bottomIndex: bottomIndex,
        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
          lastAppendedCodes, // temporary: appended codes from lazy preAdd
          iterablesIndexCount,
          iterablesIndexFilterStatus,
          iterablesEmptyRows = [],
          sortRange = function(n) {
            return cr_range(n).sort(function(A, B) {
              var order = compareNaturalOrder(newValues[A], newValues[B]);
              return order || A - B;
            });
          },
          refilter = xfilterFilter.filterAll, // for recomputing filter
          refilterFunction, // the custom filter function in use
          filterValue, // the value used for filtering (value, array, function or undefined)
          filterValuePresent, // true if filterValue contains something
          filterMode = 'all',
          filterInValues = null,
          exactRangeCache = new Map(),
          lazyFilterTargetCodes = null,
          lazyFilterTargetCodesVersion = 0,
          lazyEncodedState = null,
          indexListeners = [], // when data is added
          dimensionGroups = [],
          lo0 = 0,
          hi0 = 0,
          t = 0,
          k;

      function normalizeExactFilterValues(filterValues) {
        var uniqueValues = Array.from(new Set(filterValues));
        uniqueValues.sort(compareNaturalOrder);
        return uniqueValues;
      }

      function isLazyEncodedValue(valueToEncode) {
        var valueType = typeof valueToEncode;
        return valueToEncode == null
          || valueType === 'string'
          || valueType === 'number'
          || valueType === 'boolean'
          || valueType === 'bigint';
      }

      // ==========================================================================
      // Lazy encoded dimension path — semantic safety contract
      //
      // The lazy path stores dimension values as integer codes and defers
      // materialization of sorted values/index. All optimizations in this path
      // must preserve these invariants:
      //
      // 1. ORDERING: filterRange must use compareNaturalOrder, not raw JS < / >=,
      //    because mixed-type dimensions have type-rank ordering that differs
      //    from JS coercion. The gate is hasLazyEncodedGroupingSupport().
      //
      // 2. EQUALITY: filterExact and filterIn use Map-based code lookup, which
      //    uses SameValueZero. This differs from compareNaturalOrder for null/0
      //    (they are distinct in SameValueZero but equivalent in natural order).
      //    This is an intentional semantic tightening: null means null.
      //
      // 3. FILTER LIFECYCLE: reduce functions receive a third argument (noPrior)
      //    that distinguishes "new data" from "filter toggle." The lazy path
      //    must preserve this via resetNeeded + resetMany/resetOne, not by
      //    skipping reduce calls.
      //
      // 4. NOTIFICATION: filter changes must fire onChange('filtered') even when
      //    no filterListeners (groups) exist. Check callbacks.length too.
      //
      // 5. COUNTS: codeCounts must stay consistent through append, remove, and
      //    compaction. lazyCodesSelectAllRows depends on accurate counts.
      //
      // When in doubt, materialize. The materialized path is always correct.
      // ==========================================================================

      function createLazyEncodedState(sourceValues) {
        if (!accessorPath || iterable || !runtimeController.canUseWasmScan()) {
          return null;
        }

        var codesCapacity = sourceValues.length < 64 ? 64 : sourceValues.length,
            codes = new Uint32Array(codesCapacity),
            valueToCode = new Map(),
            codeToValue = [undefined],
            i,
            valueToEncode,
            code;

        for (i = 0; i < sourceValues.length; ++i) {
          valueToEncode = sourceValues[i];
          if (!isLazyEncodedValue(valueToEncode)) {
            return null;
          }
          if (!valueToCode.has(valueToEncode)) {
            code = codeToValue.length;
            valueToCode.set(valueToEncode, code);
            codeToValue.push(valueToEncode);
          }
          codes[i] = valueToCode.get(valueToEncode);
        }

        return {
          codeCounts: buildCodeCounts(codes, codeToValue.length),
          codesLength: sourceValues.length,
          codeToValue: codeToValue,
          codes: codes,
          matchIndices: null,
          selected: null,
          selectionMarkVersion: 1,
          selectionMarks: new Uint32Array(codeToValue.length),
          valueToCode: valueToCode
        };
      }

      function createLazyEncodedStateFromAccessor(accessor, offset, length) {
        if (!accessorPath || iterable || !runtimeController.canUseWasmScan()) {
          return null;
        }

        var codesCapacity = length < 64 ? 64 : length,
            codes = new Uint32Array(codesCapacity),
            valueToCode = new Map(),
            codeToValue = [undefined],
            i,
            valueToEncode,
            code;

        for (i = 0; i < length; ++i) {
          valueToEncode = accessor(offset + i);
          if (!isLazyEncodedValue(valueToEncode)) {
            return null;
          }
          if (!valueToCode.has(valueToEncode)) {
            code = codeToValue.length;
            valueToCode.set(valueToEncode, code);
            codeToValue.push(valueToEncode);
          }
          codes[i] = valueToCode.get(valueToEncode);
        }

        return {
          codeCounts: buildCodeCounts(codes, codeToValue.length),
          codesLength: length,
          codeToValue: codeToValue,
          codes: codes,
          matchIndices: null,
          selected: null,
          selectionMarkVersion: 1,
          selectionMarks: new Uint32Array(codeToValue.length),
          valueToCode: valueToCode
        };
      }

      function ensureLazySelectionMarksSize(size) {
        if (lazyEncodedState.selectionMarks.length >= size) {
          return;
        }

        var nextMarks = new Uint32Array(size);
        nextMarks.set(lazyEncodedState.selectionMarks);
        lazyEncodedState.selectionMarks = nextMarks;
      }

      function getLazyCodes() {
        return lazyEncodedState.codes.length === lazyEncodedState.codesLength
          ? lazyEncodedState.codes
          : lazyEncodedState.codes.subarray(0, lazyEncodedState.codesLength);
      }

      function growLazyCodeCounts(codeCounts, code) {
        var nextCounts = new Uint32Array(lazyEncodedState.codeToValue.length);
        nextCounts.set(codeCounts);
        lazyEncodedState.codeCounts = nextCounts;
        return nextCounts;
      }

      function appendLazyEncodedValues(sourceValues) {
        if (!lazyEncodedState) {
          return null;
        }

        var existingLength = lazyEncodedState.codesLength,
            newLength = existingLength + sourceValues.length,
            codes = lazyEncodedState.codes,
            codeCounts = lazyEncodedState.codeCounts,
            appendedCodes = new Uint32Array(sourceValues.length),
            i,
            valueToEncode,
            code;

        if (newLength > codes.length) {
          var nextCapacity = codes.length;
          while (nextCapacity < newLength) nextCapacity *= 2;
          var nextCodes = new Uint32Array(nextCapacity);
          nextCodes.set(codes.subarray(0, existingLength));
          codes = nextCodes;
          lazyEncodedState.codes = codes;
        }

        for (i = 0; i < sourceValues.length; ++i) {
          valueToEncode = sourceValues[i];
          if (!isLazyEncodedValue(valueToEncode)) {
            return null;
          }
          if (!lazyEncodedState.valueToCode.has(valueToEncode)) {
            code = lazyEncodedState.codeToValue.length;
            lazyEncodedState.valueToCode.set(valueToEncode, code);
            lazyEncodedState.codeToValue.push(valueToEncode);
          }
          code = lazyEncodedState.valueToCode.get(valueToEncode);
          appendedCodes[i] = code;
          codes[existingLength + i] = code;
          if (code >= codeCounts.length) {
            codeCounts = growLazyCodeCounts(codeCounts);
          }
          ++codeCounts[code];
        }

        lazyEncodedState.codesLength = newLength;
        ensureLazySelectionMarksSize(lazyEncodedState.codeToValue.length);
        return appendedCodes;
      }

      function appendLazyEncodedValuesFromAccessor(accessor, offset, length) {
        if (!lazyEncodedState) {
          return null;
        }

        var existingLength = lazyEncodedState.codesLength,
            newLength = existingLength + length,
            codes = lazyEncodedState.codes,
            codeCounts = lazyEncodedState.codeCounts,
            appendedCodes = new Uint32Array(length),
            i,
            valueToEncode,
            code;

        if (newLength > codes.length) {
          var nextCapacity = codes.length;
          while (nextCapacity < newLength) nextCapacity *= 2;
          var nextCodes = new Uint32Array(nextCapacity);
          nextCodes.set(codes.subarray(0, existingLength));
          codes = nextCodes;
          lazyEncodedState.codes = codes;
        }

        for (i = 0; i < length; ++i) {
          valueToEncode = accessor(offset + i);
          if (!isLazyEncodedValue(valueToEncode)) {
            return null;
          }
          if (!lazyEncodedState.valueToCode.has(valueToEncode)) {
            code = lazyEncodedState.codeToValue.length;
            lazyEncodedState.valueToCode.set(valueToEncode, code);
            lazyEncodedState.codeToValue.push(valueToEncode);
          }
          code = lazyEncodedState.valueToCode.get(valueToEncode);
          appendedCodes[i] = code;
          codes[existingLength + i] = code;
          if (code >= codeCounts.length) {
            codeCounts = growLazyCodeCounts(codeCounts);
          }
          ++codeCounts[code];
        }

        lazyEncodedState.codesLength = newLength;
        ensureLazySelectionMarksSize(lazyEncodedState.codeToValue.length);
        return appendedCodes;
      }

      function buildCodeCounts(codes, size) {
        var codeCounts = new Uint32Array(size);
        for (var codeIndex = 0; codeIndex < codes.length; ++codeIndex) {
          ++codeCounts[codes[codeIndex]];
        }
        return codeCounts;
      }

      function lazyCodesSelectAllRows(targetCodes) {
        if (!lazyEncodedState || !targetCodes || !targetCodes.length) {
          return false;
        }

        var selectedCount = 0;
        for (var codeIndex = 0; codeIndex < targetCodes.length; ++codeIndex) {
          selectedCount += lazyEncodedState.codeCounts[targetCodes[codeIndex]] || 0;
        }
        return selectedCount === n;
      }

      function normalizeLazySelectionMask(selection) {
        if (!selection) {
          return null;
        }

        for (var i = 0; i < selection.length; ++i) {
          if (!selection[i]) {
            return selection;
          }
        }

        return null;
      }

      function normalizeLazyMatchIndices(matches) {
        if (!matches || matches.length === n) {
          return null;
        }
        return matches;
      }

      function createLazySelectionFromMatches(matches) {
        if (!matches || matches.length === n) {
          return null;
        }

        var selection = new Uint8Array(n);
        for (var i = 0; i < matches.length; ++i) {
          selection[matches[i]] = 1;
        }
        return selection;
      }

      function ensureLazySelection(currentMatches, currentSelected) {
        return currentSelected || createLazySelectionFromMatches(currentMatches);
      }

      function encodeLazyFilterValues(filterValues) {
        if (!lazyEncodedState) {
          return null;
        }

        var encodedValues = new Uint32Array(filterValues.length),
            count = 0,
            i,
            markVersion,
            selectionMarks,
            valueToEncode,
            code;

        ensureLazySelectionMarksSize(lazyEncodedState.codeToValue.length);
        selectionMarks = lazyEncodedState.selectionMarks;
        if (lazyEncodedState.selectionMarkVersion === 0xffffffff) {
          selectionMarks.fill(0);
          lazyEncodedState.selectionMarkVersion = 1;
        }
        markVersion = lazyEncodedState.selectionMarkVersion++;

        for (i = 0; i < filterValues.length; ++i) {
          valueToEncode = filterValues[i];
          if (!isLazyEncodedValue(valueToEncode)) {
            return null;
          }
          code = lazyEncodedState.valueToCode.get(valueToEncode);
          if (code === undefined || selectionMarks[code] === markVersion) {
            continue;
          }
          selectionMarks[code] = markVersion;
          encodedValues[count++] = code;
        }

        return encodedValues.slice(0, count);
      }

      function applyLazySelectionState(nextMatches) {
        var shouldNotify = filterListeners.length > 0 || callbacks.length > 0,
            added = shouldNotify ? [] : null,
            removed = shouldNotify ? [] : null,
            currentSelected = lazyEncodedState.selected,
            currentMatches = normalizeLazyMatchIndices(lazyEncodedState.matchIndices),
            currentIndex,
            nextIndex,
            currentValue,
            nextValue,
            i,
            isSelected,
            nextSelected,
            wasSelected;

        nextMatches = normalizeLazyMatchIndices(nextMatches);

        if (!currentMatches && !nextMatches) {
          lazyEncodedState.selected = null;
          lazyEncodedState.matchIndices = null;
          return dimension;
        }

        if (currentMatches && nextMatches) {
          currentSelected = ensureLazySelection(currentMatches, currentSelected);
          currentIndex = 0;
          nextIndex = 0;

          while (currentIndex < currentMatches.length || nextIndex < nextMatches.length) {
            currentValue = currentIndex < currentMatches.length ? currentMatches[currentIndex] : n;
            nextValue = nextIndex < nextMatches.length ? nextMatches[nextIndex] : n;

            if (currentValue === nextValue) {
              ++currentIndex;
              ++nextIndex;
              continue;
            }

            if (currentValue < nextValue) {
              if (!(filters[offset][currentValue] & one)) {
                filters[offset][currentValue] |= one;
              }
              currentSelected[currentValue] = 0;
              if (shouldNotify) {
                removed.push(currentValue);
              }
              ++currentIndex;
              continue;
            }

            if (filters[offset][nextValue] & one) {
              filters[offset][nextValue] &= zero;
            }
            currentSelected[nextValue] = 1;
            if (shouldNotify) {
              added.push(nextValue);
            }
            ++nextIndex;
          }

          lazyEncodedState.selected = normalizeLazySelectionMask(currentSelected);
          lazyEncodedState.matchIndices = nextMatches;
          if (shouldNotify) {
            notifyFilterListeners(one, offset, added, removed);
          }
          return dimension;
        }

        nextSelected = createLazySelectionFromMatches(nextMatches);
        currentSelected = ensureLazySelection(currentMatches, currentSelected);

        if (!currentSelected && !nextSelected) {
          lazyEncodedState.selected = null;
          lazyEncodedState.matchIndices = null;
          return dimension;
        }

        for (i = 0; i < n; ++i) {
          wasSelected = currentSelected ? currentSelected[i] === 1 : true;
          isSelected = nextSelected ? nextSelected[i] === 1 : true;
          if (wasSelected === isSelected) {
            continue;
          }
          if (isSelected) {
            if (filters[offset][i] & one) {
              filters[offset][i] &= zero;
            }
            if (shouldNotify) {
              added.push(i);
            }
          } else {
            if (!(filters[offset][i] & one)) {
              filters[offset][i] |= one;
            }
            if (shouldNotify) {
              removed.push(i);
            }
          }
        }

        lazyEncodedState.selected = nextSelected;
        lazyEncodedState.matchIndices = nextMatches;
        if (shouldNotify) {
          notifyFilterListeners(one, offset, added, removed);
        }
        return dimension;
      }

      function applyLazyEncodedFilter(targetCodes, nextMode) {
        var matches;

        if (lazyCodesSelectAllRows(targetCodes)) {
          filterMode = nextMode;
          lo0 = 0;
          hi0 = 0;
          return applyLazySelectionState(null);
        }

        matches = runtimeController.findEncodedMatches(getLazyCodes(), targetCodes);
        // Copy from possible WASM memory view before it can be invalidated
        matches = new Uint32Array(matches);

        filterMode = nextMode;
        lo0 = 0;
        hi0 = 0;

        return applyLazySelectionState(matches);
      }

      function resolveLazyTargetCodes() {
        if (!lazyEncodedState || !filterValuePresent || filterMode === 'all') {
          return new Uint32Array(0);
        }

        if (lazyFilterTargetCodes) {
          var currentCodeCount = lazyEncodedState.codeToValue.length;
          if (currentCodeCount === lazyFilterTargetCodesVersion) {
            return lazyFilterTargetCodes;
          }
          // New codes appeared — rescan
          var codeToValue = lazyEncodedState.codeToValue,
              rangeCodes = [],
              code,
              v,
              range = filterValue;

          for (code = 1; code < codeToValue.length; ++code) {
            v = codeToValue[code];
            if (compareNaturalOrder(v, range[0]) >= 0 && compareNaturalOrder(v, range[1]) < 0) {
              rangeCodes.push(code);
            }
          }
          lazyFilterTargetCodes = new Uint32Array(rangeCodes);
          lazyFilterTargetCodesVersion = currentCodeCount;
          return lazyFilterTargetCodes;
        }

        if (filterMode === 'in') {
          return encodeLazyFilterValues(filterInValues || []);
        }

        return encodeLazyFilterValues([filterValue]);
      }

      function concatLazyMatchIndices(currentMatches, appendedMatches) {
        if (!currentMatches || !currentMatches.length) {
          return appendedMatches;
        }
        if (!appendedMatches || !appendedMatches.length) {
          return currentMatches;
        }

        var nextMatches = new Uint32Array(currentMatches.length + appendedMatches.length);
        nextMatches.set(currentMatches);
        nextMatches.set(appendedMatches, currentMatches.length);
        return nextMatches;
      }

      function applyLazyFilterToNewRows(n0, appendedCodes) {
        var currentMatches = normalizeLazyMatchIndices(lazyEncodedState.matchIndices),
            currentSelected,
            nextMatches,
            nextSelected,
            matches,
            i,
            rowIndex,
            targetCodes;

        if (!currentMatches) {
          return;
        }

        targetCodes = resolveLazyTargetCodes();
        if (!targetCodes) {
          materializeLazyEncodedState();
          return;
        }

        currentSelected = ensureLazySelection(currentMatches, lazyEncodedState.selected);
        if (currentSelected.length >= n) {
          // Buffer is already large enough — reuse it directly.
          nextSelected = currentSelected;
        } else {
          // Must grow — allocate exact size to preserve normalizeLazySelectionMask semantics.
          nextSelected = new Uint8Array(n);
          nextSelected.set(currentSelected);
        }
        matches = runtimeController.findEncodedMatches(appendedCodes, targetCodes);
        nextMatches = new Uint32Array(matches.length);

        for (i = 0; i < matches.length; ++i) {
          rowIndex = n0 + matches[i];
          nextSelected[rowIndex] = 1;
          nextMatches[i] = rowIndex;
        }

        for (rowIndex = n0; rowIndex < n; ++rowIndex) {
          if (!nextSelected[rowIndex]) {
            filters[offset][rowIndex] |= one;
          }
        }

        lazyEncodedState.matchIndices = normalizeLazyMatchIndices(concatLazyMatchIndices(currentMatches, nextMatches));
        lazyEncodedState.selected = normalizeLazySelectionMask(nextSelected);
      }

      function compactLazyEncodedState(reIndex) {
        var currentMatches = normalizeLazyMatchIndices(lazyEncodedState.matchIndices),
            nextLength = 0,
            i,
            nextCodes,
            nextMatchCount = 0,
            nextMatchIndices = currentMatches ? new Uint32Array(currentMatches.length) : null,
            nextSelected = lazyEncodedState.selected ? new Uint8Array(reIndex.length) : null,
            rowIndex;

        for (i = 0; i < reIndex.length; ++i) {
          if (reIndex[i] !== REMOVED_INDEX) {
            ++nextLength;
          }
        }

        var nextCodesCapacity = nextLength < 64 ? 64 : nextLength;
        nextCodes = new Uint32Array(nextCodesCapacity);
        if (nextSelected) {
          nextSelected = new Uint8Array(nextLength);
        }

        var existingCodes = getLazyCodes();
        for (i = 0, rowIndex = 0; i < reIndex.length; ++i) {
          if (reIndex[i] === REMOVED_INDEX) {
            continue;
          }
          nextCodes[rowIndex] = existingCodes[i];
          if (nextSelected && lazyEncodedState.selected[i]) {
            nextSelected[rowIndex] = 1;
          }
          ++rowIndex;
        }

        if (nextMatchIndices) {
          for (i = 0; i < currentMatches.length; ++i) {
            rowIndex = reIndex[currentMatches[i]];
            if (rowIndex === REMOVED_INDEX) {
              continue;
            }
            nextMatchIndices[nextMatchCount++] = rowIndex;
          }
          nextMatchIndices = normalizeLazyMatchIndices(nextMatchIndices.slice(0, nextMatchCount));
        }

        lazyEncodedState.codes = nextCodes;
        lazyEncodedState.codesLength = nextLength;
        lazyEncodedState.codeCounts = buildCodeCounts(
          nextCodes.subarray(0, nextLength),
          lazyEncodedState.codeToValue.length
        );
        lazyEncodedState.matchIndices = nextMatchIndices;
        lazyEncodedState.selected = normalizeLazySelectionMask(nextSelected);
        lo0 = 0;
        hi0 = 0;
      }

      function materializeLazyEncodedState() {
        if (!lazyEncodedState || values) {
          return;
        }

        var lazyCodes = getLazyCodes(),
            materializedValues = new Array(lazyCodes.length),
            bounds,
            i,
            ranges;

        for (i = 0; i < materializedValues.length; ++i) {
          materializedValues[i] = lazyEncodedState.codeToValue[lazyCodes[i]];
        }

        newValues = materializedValues;
        newIndex = sortRange(materializedValues.length);
        values = permute(newValues, newIndex);
        index = newIndex;
        newValues = newIndex = null;
        exactRangeCache.clear();

        if (filterMode === 'in') {
          ranges = exactRanges(filterInValues || []);
          lo0 = ranges.length ? ranges[0][0] : 0;
          hi0 = ranges.length ? ranges[ranges.length - 1][1] : 0;
        } else {
          bounds = refilter(values);
          lo0 = bounds[0];
          hi0 = bounds[1];
        }

        lazyEncodedState = null;
      }

      function hasLazyEncodedGroupingSupport() {
        if (!lazyEncodedState || values || iterable) {
          return false;
        }

        for (var code = 1; code < lazyEncodedState.codeToValue.length; ++code) {
          var encodedValue = lazyEncodedState.codeToValue[code];
          if (encodedValue === undefined || !(encodedValue >= encodedValue)) {
            return false;
          }
        }

        return true;
      }

      function setFilterValuePresent(nextPresent) {
        var currentPresent = filterValuePresent === true;
        nextPresent = !!nextPresent;
        if (currentPresent === nextPresent) {
          return;
        }
        activeDimensionFilterCount += nextPresent ? 1 : -1;
        filterValuePresent = nextPresent;
      }

      function hasOtherActiveDimensionFilters() {
        return activeDimensionFilterCount > (filterValuePresent ? 1 : 0);
      }

      function getExactRange(value) {
        if (exactRangeCache.has(value)) {
          return exactRangeCache.get(value);
        }

        var lo = bisect.left(values, value, 0, values.length),
            hi = bisect.right(values, value, lo, values.length),
            range = lo === hi ? null : [lo, hi];

        exactRangeCache.set(value, range);
        return range;
      }

      function exactRanges(filterValues) {
        if (!filterValues || !filterValues.length) {
          return [];
        }

        var ranges = [];
        for (var valueIndex = 0; valueIndex < filterValues.length; ++valueIndex) {
          var range = getExactRange(filterValues[valueIndex]),
              lastRange = ranges[ranges.length - 1];

          if (!range) {
            continue;
          }

          if (lastRange && range[0] <= lastRange[1]) {
            lastRange[1] = Math.max(lastRange[1], range[1]);
          } else {
            ranges.push([range[0], range[1]]);
          }
        }

        return ranges;
      }

      function resolveCurrentRanges() {
        if (!values) {
          return [];
        }

        switch (filterMode) {
          case 'all':
            return values.length ? [[0, values.length]] : [];
          case 'bounds':
            return lo0 === hi0 ? [] : [[lo0, hi0]];
          case 'in':
            return exactRanges(filterInValues);
          default:
            return null;
        }
      }

      function appendIndexedRange(rows, rowIndexes, start, end) {
        for (var i = start; i < end; ++i) {
          rows.push(index[i]);
          rowIndexes.push(i);
        }
      }

      function applyFilterChanges(added, removed, valueIndexAdded, valueIndexRemoved, includeEmptyRows) {
        var i,
            row;

        if(!iterable) {
          for(i = 0; i < added.length; i++) {
            filters[offset][added[i]] ^= one;
          }

          for(i = 0; i < removed.length; i++) {
            filters[offset][removed[i]] ^= one;
          }
        } else {
          var newAdded = [];
          var newRemoved = [];

          for (i = 0; i < added.length; i++) {
            iterablesIndexCount[added[i]]++;
            iterablesIndexFilterStatus[valueIndexAdded[i]] = 0;
            if(iterablesIndexCount[added[i]] === 1) {
              filters[offset][added[i]] ^= one;
              newAdded.push(added[i]);
            }
          }
          for (i = 0; i < removed.length; i++) {
            iterablesIndexCount[removed[i]]--;
            iterablesIndexFilterStatus[valueIndexRemoved[i]] = 1;
            if(iterablesIndexCount[removed[i]] === 0) {
              filters[offset][removed[i]] ^= one;
              newRemoved.push(removed[i]);
            }
          }

          added = newAdded;
          removed = newRemoved;

          if(includeEmptyRows) {
            for(i = 0; i < iterablesEmptyRows.length; i++) {
              if((filters[offset][row = iterablesEmptyRows[i]] & one)) {
                filters[offset][row] ^= one;
                added.push(row);
              }
            }
          } else {
            for(i = 0; i < iterablesEmptyRows.length; i++) {
              if(!(filters[offset][row = iterablesEmptyRows[i]] & one)) {
                filters[offset][row] ^= one;
                removed.push(row);
              }
            }
          }
        }

        notifyFilterListeners(one, offset, added, removed);
        return dimension;
      }

      function filterIndexRanges(oldRanges, newRanges, includeEmptyRows) {
        var added = [],
            removed = [],
            valueIndexAdded = [],
            valueIndexRemoved = [],
            previousRanges = oldRanges.map(function(range) { return [range[0], range[1]]; }),
            nextRanges = newRanges.map(function(range) { return [range[0], range[1]]; }),
            oldIndex = 0,
            newIndexPointer = 0;

        while (oldIndex < previousRanges.length || newIndexPointer < nextRanges.length) {
          var oldRange = previousRanges[oldIndex],
              newRange = nextRanges[newIndexPointer];

          if (!oldRange) {
            appendIndexedRange(added, valueIndexAdded, newRange[0], newRange[1]);
            ++newIndexPointer;
            continue;
          }

          if (!newRange) {
            appendIndexedRange(removed, valueIndexRemoved, oldRange[0], oldRange[1]);
            ++oldIndex;
            continue;
          }

          if (oldRange[1] <= newRange[0]) {
            appendIndexedRange(removed, valueIndexRemoved, oldRange[0], oldRange[1]);
            ++oldIndex;
            continue;
          }

          if (newRange[1] <= oldRange[0]) {
            appendIndexedRange(added, valueIndexAdded, newRange[0], newRange[1]);
            ++newIndexPointer;
            continue;
          }

          if (oldRange[0] < newRange[0]) {
            appendIndexedRange(removed, valueIndexRemoved, oldRange[0], newRange[0]);
          } else if (newRange[0] < oldRange[0]) {
            appendIndexedRange(added, valueIndexAdded, newRange[0], oldRange[0]);
          }

          if (oldRange[1] < newRange[1]) {
            nextRanges[newIndexPointer] = [oldRange[1], newRange[1]];
            ++oldIndex;
          } else if (newRange[1] < oldRange[1]) {
            previousRanges[oldIndex] = [newRange[1], oldRange[1]];
            ++newIndexPointer;
          } else {
            ++oldIndex;
            ++newIndexPointer;
          }
        }

        lo0 = newRanges.length ? newRanges[0][0] : 0;
        hi0 = newRanges.length ? newRanges[newRanges.length - 1][1] : 0;

        return applyFilterChanges(added, removed, valueIndexAdded, valueIndexRemoved, includeEmptyRows);
      }

      // 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) {
        var newIterablesIndexCount,
            sourceValues = null,
            columnAccessorSegment = accessorPath && !iterable && runtimeController.canUseWasmScan()
              ? findSingleColumnAccessorSegment(accessorPath, n0, n1)
              : null,
            useStoredRecords = !accessorPath && newData === data && columnarBatches.length,
            newIterablesIndexFilterStatus;

        function ensureSourceValues() {
          if (!accessorPath) {
            return null;
          }
          if (!sourceValues) {
            sourceValues = extractColumnValues(accessorPath, n0, n1);
          }
          return sourceValues;
        }

        function getSourceRecord(localIndex) {
          return useStoredRecords ? getRecord(n0 + localIndex) : newData[localIndex];
        }

        if (!iterable && accessorPath) {
          if (!n0 && !values) {
            lazyEncodedState = columnAccessorSegment
              ? createLazyEncodedStateFromAccessor(columnAccessorSegment.accessor, columnAccessorSegment.offset, n1)
              : createLazyEncodedState(ensureSourceValues());
            if (lazyEncodedState) {
              if (filterValuePresent && filterMode !== 'all') {
                var initialTargetCodes = resolveLazyTargetCodes();
                if (initialTargetCodes) {
                  var initialMatches = initialTargetCodes.length
                    ? runtimeController.findEncodedMatches(getLazyCodes(), initialTargetCodes)
                    : new Uint32Array(0);
                  initialMatches = new Uint32Array(initialMatches);
                  var initialSelected = new Uint8Array(n1);
                  for (var mi = 0; mi < initialMatches.length; ++mi) {
                    initialSelected[initialMatches[mi]] = 1;
                  }
                  for (var ri = 0; ri < n1; ++ri) {
                    if (!initialSelected[ri]) {
                      filters[offset][ri] |= one;
                    }
                  }
                  lazyEncodedState.matchIndices = normalizeLazyMatchIndices(initialMatches);
                  lazyEncodedState.selected = normalizeLazySelectionMask(initialSelected);
                }
              }
              lastAppendedCodes = getLazyCodes();
              lo0 = 0;
              hi0 = 0;
              return;
            }
          } else if (lazyEncodedState && !values) {
            var appendedCodes = columnAccessorSegment
              ? appendLazyEncodedValuesFromAccessor(columnAccessorSegment.accessor, columnAccessorSegment.offset, n1)
              : appendLazyEncodedValues(ensureSourceValues());
            if (appendedCodes) {
              applyLazyFilterToNewRows(n0, appendedCodes);
              lastAppendedCodes = appendedCodes;
              lo0 = 0;
              hi0 = 0;
              return;
            }
            materializeLazyEncodedState();
          }
        }

        if (iterable){
          sourceValues = ensureSourceValues();
          // Count all the values
          t = 0;
          j = 0;
          k = [];

          for (var i0 = 0; i0 < newData.length; i0++) {
            for(j = 0, k = sourceValues ? sourceValues[i0] : value(getSourceRecord(i0)); j < k.length; j++) {
              t++;
            }
          }

          newValues = [];
          newIterablesIndexCount = cr_range(newData.length);
          newIterablesIndexFilterStatus = cr_index(t,1);
          var unsortedIndex = cr_range(t);

          for (var l = 0, index1 = 0; index1 < newData.length; index1++) {
            k = sourceValues ? sourceValues[index1] : value(getSourceRecord(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 = sortRange(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.
          sourceValues = ensureSourceValues();
          if (sourceValues) {
            newValues = sourceValues;
          } else if (useStoredRecords) {
            newValues = new Array(n1);
            for (var recordIndex = 0; recordIndex < n1; ++recordIndex) {
              newValues[recordIndex] = value(getSourceRecord(recordIndex));
            }
          } else {
            newValues = newData.map(value);
          }
          newIndex = sortRange(n1);
          newValues = permute(newValues, newIndex);
        }

        // Bisect newValues to determine which new records are selected.
        var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1];

        var index2, index3, index4;
        if(iterable) {
          n1 = t;
          if (refilterFunction) {
            for (index2 = 0; index2 < n1; ++index2) {
              if (!refilterFunction(newValues[index2], index2)) {
                if(--newIterablesIndexCount[newIndex[index2]] === 0) {
                  filters[offset][newIndex[index2] + n0] |= one;
                }
                newIterablesIndexFilterStatus[index2] = 1;
              }
            }
          } else {
            for (index3 = 0; index3 < lo1; ++index3) {
              if(--newIterablesIndexCount[newIndex[index3]] === 0) {
                filters[offset][newIndex[index3] + n0] |= one;
              }
              newIterablesIndexFilterStatus[index3] = 1;
            }
            for (index4 = hi1; index4 < n1; ++index4) {
              if(--newIterablesIndexCount[newIndex[index4]] === 0) {
                filters[offset][newIndex[index4] + n0] |= one;
              }
              newIterablesIndexFilterStatus[index4] = 1;
            }
          }
        } else {
          if (refilterFunction) {
            for (index2 = 0; index2 < n1; ++index2) {
              if (!refilterFunction(newValues[index2], index2)) {
                filters[offset][newIndex[index2] + n0] |= one;
              }
            }
          } else {
            for (index3 = 0; index3 < lo1; ++index3) {
              filters[offset][newIndex[index3] + n0] |= one;
            }
            for (index4 = hi1; index4 < n1; ++index4) {
              filters[offset][newIndex[index4] + n0] |= one;
            }
          }
        }

        // 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;
          exactRangeCache.clear();
          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) : cr_index(n, n);
        if(iterable) iterablesIndexFilterStatus = cr_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 (compareNaturalOrder(oldValues[i0], newValues[i1]) < 0) {
            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.
        exactRangeCache.clear();
        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, lastAppendedCodes); });
        newValues = newIndex = null;
        lastAppendedCodes = null;
      }

      function removeData(reIndex) {
        if (lazyEncodedState && !values) {
          compactLazyEncodedState(reIndex);
          return;
        }

        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 = iterablesIndexCount.slice(0, 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 = iterablesIndexFilterStatus.slice(0, j);
        while (j < n0) index[j++] = 0;

        // Bisect again to recompute lo0 and hi0.
        exactRangeCache.clear();
        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, includeEmptyRows, nextMode) {
        var lo1 = bounds[0],
            hi1 = bounds[1],
            previousMode = filterMode,
            oldRanges = resolveCurrentRanges(),
            newRanges = lo1 === hi1 ? [] : [[lo1, hi1]];

        if (includeEmptyRows === undefined) {
          includeEmptyRows = false;
        }
        if (nextMode === undefined) {
          nextMode = 'bounds';
        }

        if (oldRanges === null) {
          refilterFunction = null;
          filterMode = nextMode;
          filterInValues = null;
          filterIndexFunction(function(d, i) { return lo1 <= i && i < hi1; }, includeEmptyRows);
          lo0 = lo1;
          hi0 = hi1;
          return dimension;
        }

        refilterFunction = null;
        filterMode = nextMode;
        filterInValues = null;

        if (previousMode === 'in') {
          return filterIndexRanges(oldRanges, newRanges, includeEmptyRows);
        }

        var i,
            j,
            added = [],
            removed = [],
            valueIndexAdded = [],
            valueIndexRemoved = [];

        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);
          }
        }

        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);
          }
        }

        lo0 = lo1;
        hi0 = hi1;

        return applyFilterChanges(added, removed, valueIndexAdded, valueIndexRemoved, includeEmptyRows);
      }

      // Filters this dimension using the specified range, value, or null.
      // If the range is null, this is equivalent to filterAll.
      // If the range is an array, this is equivalent to filterRange.
      // Otherwise, this is equivalent to filterExact.
      function filter(range) {
        return range == null
            ? filterAll() : Array.isArray(range)
            ? filterRange(range) : typeof range === "function"
            ? filterFunction(range)
            : filterExact(range);
      }

      // Filters this dimension to select the exact value.
      function filterExact(value) {
        lazyFilterTargetCodes = null;
        lazyFilterTargetCodesVersion = 0;
        if (lazyEncodedState && !values) {
          var exactCodes = encodeLazyFilterValues([value]);
          if (exactCodes) {
            filterValue = value;
            setFilterValuePresent(true);
            refilter = xfilterFilter.filterExact(bisect, value);
            refilterFunction = null;
            filterInValues = null;
            return applyLazyEncodedFilter(exactCodes, 'bounds');
          }
          materializeLazyEncodedState();
        }

        filterValue = value;
        setFilterValuePresent(true);
        refilter = xfilterFilter.filterExact(bisect, value);
        var range = getExactRange(value);
        return filterIndexBounds(range || [0, 0], false, 'bounds');
      }

      function filterIn(valuesToSelect) {
        lazyFilterTargetCodes = null;
        lazyFilterTargetCodesVersion = 0;
        if (lazyEncodedState && !values) {
          var lazyExactFilterValues = normalizeExactFilterValues(valuesToSelect),
              lazyEncodedValues = encodeLazyFilterValues(lazyExactFilterValues);

          if (lazyEncodedValues) {
            filterValue = valuesToSelect;
            setFilterValuePresent(true);
            refilter = xfilterFilter.filterAll;
            refilterFunction = null;
            filterMode = 'in';
            filterInValues = lazyExactFilterValues;
            return applyLazyEncodedFilter(lazyEncodedValues, 'in');
          }

          materializeLazyEncodedState();
        }

        var exactFilterValues = normalizeExactFilterValues(valuesToSelect),
            nextRanges = exactRanges(exactFilterValues),
            previousRanges = resolveCurrentRanges(),
            selectedValues = new Set(exactFilterValues),
            predicate = function(d) { return selectedValues.has(d); };

        filterValue = valuesToSelect;
        setFilterValuePresent(true);
        refilter = xfilterFilter.filterAll;
        refilterFunction = predicate;
        filterMode = 'in';
        filterInValues = exactFilterValues;

        if (previousRanges === null) {
          filterIndexFunction(predicate, false);
          lo0 = nextRanges.length ? nextRanges[0][0] : 0;
          hi0 = nextRanges.length ? nextRanges[nextRanges.length - 1][1] : 0;
          return dimension;
        }

        return filterIndexRanges(previousRanges, nextRanges, false);
      }

      // Filters this dimension to select the specified range [lo, hi].
      // The lower bound is inclusive, and the upper bound is exclusive.
      function filterRange(range) {
        if (lazyEncodedState && !values && hasLazyEncodedGroupingSupport()) {
          var codeToValue = lazyEncodedState.codeToValue,
              rangeCodes = [],
              rangeCode,
              rangeValue;

          for (rangeCode = 1; rangeCode < codeToValue.length; ++rangeCode) {
            rangeValue = codeToValue[rangeCode];
            if (compareNaturalOrder(rangeValue, range[0]) >= 0 && compareNaturalOrder(rangeValue, range[1]) < 0) {
              rangeCodes.push(rangeCode);
            }
          }

          filterValue = range;
          setFilterValuePresent(true);
          refilter = xfilterFilter.filterRange(bisect, range);
          refilterFunction = null;
          filterInValues = null;
          filterMode = 'bounds';
          lazyFilterTargetCodes = new Uint32Array(rangeCodes);
          lazyFilterTargetCodesVersion = codeToValue.length;
          return applyLazyEncodedFilter(lazyFilterTargetCodes, 'bounds');
        }

        if (lazyEncodedState && !values) {
          materializeLazyEncodedState();
        }

        filterValue = range;
        setFilterValuePresent(true);
        return filterIndexBounds((refilter = xfilterFilter.filterRange(bisect, range))(values), false, 'bounds');
      }

      // Clears any filters on this dimension.
      function filterAll() {
        lazyFilterTargetCodes = null;
        lazyFilterTargetCodesVersion = 0;
        if (lazyEncodedState && !values) {
          filterValue = undefined;
          setFilterValuePresent(false);
          refilter = xfilterFilter.filterAll;
          refilterFunction = null;
          filterInValues = null;
          return applyLazySelectionState(null);
        }

        filterValue = undefined;
        setFilterValuePresent(false);
        refilter = xfilterFilter.filterAll;

        return filterIndexBounds((refilter = xfilterFilter.filterAll)(values), true, 'all');
      }

      // Filters this dimension using an arbitrary function.
      function filterFunction(f) {
        lazyFilterTargetCodes = null;
        lazyFilterTargetCodesVersion = 0;
        if (lazyEncodedState && !values) {
          materializeLazyEncodedState();
        }

        filterValue = f;
        setFilterValuePresent(true);

        refilterFunction = f;
        refilter = xfilterFilter.filterAll;
        filterMode = 'function';
        filterInValues = null;

        filterIndexFunction(f, false);

        var bounds = refilter(values);
        lo0 = bounds[0], hi0 = bounds[1];

        return dimension;
      }

      function filterIndexFunction(f, filterAll) {
        var i,
            k,
            x,
            added = [],
            removed = [],
            valueIndexAdded = [],
            valueIndexRemoved = [],
            indexLength = values.length;

        if(!iterable) {
          for (i = 0; i < indexLength; ++i) {
            if (!(filters[offset][k = index[i]] & one) ^ !!(x = f(values[i], i))) {
              if (x) added.push(k);
              else removed.push(k);
            }
          }
        }

        if(iterable) {
          for(i=0; i < indexLength; ++i) {
            if(f(values[i], i)) {
              added.push(index[i]);
              valueIndexAdded.push(i);
            } else {
              removed.push(index[i]);
              valueIndexRemoved.push(i);
            }
          }
        }

        if(!iterable) {
          for(i=0; i<added.length; i++) {
            if(filters[offset][added[i]] & one) filters[offset][added[i]] &= zero;
          }

          for(i=0; i<removed.length; i++) {
            if(!(filters[offset][removed[i]] & one)) filters[offset][removed[i]] |= one;
          }
        } else {

          var newAdded = [];
          var newRemoved = [];
          for (i = 0; i < added.length; i++) {
            // First check this particular value needs to be added
            if(iterablesIndexFilterStatus[valueIndexAdded[i]] === 1) {
              iterablesIndexCount[added[i]]++;
              iterablesIndexFilterStatus[valueIndexAdded[i]] = 0;
              if(iterablesIndexCount[added[i]] === 1) {
                filters[offset][added[i]] ^= one;
                newAdded.push(added[i]);
              }
            }
          }
          for (i = 0; i < removed.length; i++) {
            // First check this particular value needs to be removed
            if(iterablesIndexFilterStatus[valueIndexRemoved[i]] === 0) {
              iterablesIndexCount[removed[i]]--;
              iterablesIndexFilterStatus[valueIndexRemoved[i]] = 1;
              if(iterablesIndexCount[removed[i]] === 0) {
                filters[offset][removed[i]] ^= one;
                newRemoved.push(removed[i]);
              }
            }
          }

          added = newAdded;
          removed = newRemoved;

          // Now handle empty rows.
          if(filterAll) {
            for(i = 0; i < iterablesEmptyRows.length; i++) {
              if((filters[offset][k = iterablesEmptyRows[i]] & one)) {
                // Was not in the filter, so set the filter and add
                filters[offset][k] ^= one;
                added.push(k);
              }
            }
          } else {
            // filter in place - remove empty rows if necessary
            for(i = 0; i < iterablesEmptyRows.length; i++) {
              if(!(filters[offset][k = iterablesEmptyRows[i]] & one)) {
                // Was in the filter, so set the filter and remove
                filters[offset][k] ^= one;
                removed.push(k);
              }
            }
          }
        }

        notifyFilterListeners(one, offset, added, removed);
      }

      function currentFilter() {
        return filterValue;
      }

      function hasCurrentFilter() {
        return filterValuePresent;
      }

      // Returns the top K selected records based on this dimension's order.
      // Note: observes this dimension's filter, unlike group and groupAll.
      function top(k, top_offset) {
        materializeLazyEncodedState();

        var array = [],
            i = hi0,
            j,
            toSkip = 0;

        if(top_offset && top_offset > 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(getRecord(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(getRecord(j));
                --k;
              }
            }
          }
        }

        return array;
      }

      function topIndex(k, top_offset) {
        materializeLazyEncodedState();

        var array = [],
            i = hi0,
            j,
            toSkip = 0;

        if(top_offset && top_offset > 0) toSkip = top_offset;

        while (--i >= lo0 && k > 0) {
          if (filters.zero(j = index[i])) {
            if(toSkip > 0) {
              --toSkip;
            } else {
              array.push(j);
              --k;
            }
          }
        }

        if(iterable){
          for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) {
            if(filters.zero(j = iterablesEmptyRows[i])) {
              if(toSkip > 0) {
                --toSkip;
              } else {
                array.push(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) {
        materializeLazyEncodedState();

        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(getRecord(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(getRecord(j));
              --k;
            }
          }
          i++;
        }

        return array;
      }

      function bottomIndex(k, bottom_offset) {
        materializeLazyEncodedState();

        var array = [],
            i,
            j,
            toSkip = 0;

        if(bottom_offset && bottom_offset > 0) toSkip = bottom_offset;

        if(iterable) {
          for(i = 0; i < iterablesEmptyRows.length && k > 0; i++) {
            if(filters.zero(j = iterablesEmptyRows[i])) {
              if(toSkip > 0) {
                --toSkip;
              } else {
                array.push(j);
                --k;
              }
            }
          }
        }

        i = lo0;

        while (i < hi0 && k > 0) {
          if (filters.zero(j = index[i])) {
            if(toSkip > 0) {
              --toSkip;
            } else {
              array.push(j);
              --k;
            }
          }
          i++;
        }

        return array;
      }

      // Adds a new group to this dimension, using the specified key function.
      function group(key) {
        if (arguments.length < 1) key = cr_identity;

        var useLazyEncodedGrouping = (key === cr_identity || key === cr_null) && hasLazyEncodedGroupingSupport();
        if (!useLazyEncodedGrouping) {
          materializeLazyEncodedState();
        }

        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 = capacity(groupWidth),
            k = 0, // cardinality
            lazyCodeToGroup = null,
            select,
            heap,
            reduceAdd,
            reduceRemove,
            reduceInitial,
            reduceMetricSpec = null,
            reduceMode = null,
            update = cr_null,
            reset = cr_null,
            resetNeeded = true,
            markResetNeeded = registerResetListener(function() {
              resetNeeded = true;
            }),
            groupAll = key === cr_null,
            n0old;

        // 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, appendedCodes) {

          // Incremental lazy append: groups already exist, dimension is still encoded
          if (appendedCodes && lazyEncodedState && !values && k > 0) {
            // groupAll (k=1, no groupIndex): just mark reset needed
            if (groupAll) {
              resetNeeded = true;
              return;
            }

            if (lazyCodeToGroup) {
            var hasNewGroups = false,
                incrCode,
                incrI;

            for (incrI = 0; incrI < appendedCodes.length; ++incrI) {
              incrCode = appendedCodes[incrI];
              if (incrCode > 0 && lazyCodeToGroup[incrCode] === undefined) {
                hasNewGroups = true;
                break;
              }
            }

            if (!hasNewGroups) {
              // Fast path: extend groupIndex for new rows, no new groups
              if (k > 1) {
                groupIndex = xfilterArray.arrayLengthen(groupIndex, n);
                for (incrI = 0; incrI < appendedCodes.length; ++incrI) {
                  groupIndex[n0 + incrI] = lazyCodeToGroup[appendedCodes[incrI]];
                }
              }
              resetNeeded = true;
              return;
            }
            // hasNewGroups: fall through to full lazy rebuild below
            }
          }

          if (useLazyEncodedGrouping && lazyEncodedState && !values) {
            var codeToValue = lazyEncodedState.codeToValue,
                codes = getLazyCodes(),
                sortedCodes = [],
                initialValue = resetNeeded ? cr_null : reduceInitial,
                rowIndex,
                encodedCode,
                sortIndex;

            groups = [];
            k = 0;

            for (var code = 1; code < codeToValue.length; ++code) {
              if (!isNaturallyOrderable(codeToValue[code])) {
                continue;
              }
              sortedCodes.push(code);
            }

            sortedCodes.sort(function(a, b) {
              var valueA = codeToValue[a],
                  valueB = codeToValue[b];
              var order = compareNaturalOrder(valueA, valueB);
              return order || a - b;
            });

            if (groupAll) {
              k = 1;
              groups = [{key: null, value: initialValue()}];
              groupIndex = null;
              lazyCodeToGroup = null;
            } else if (!sortedCodes.length) {
              k = 0;
              groups = [];
              groupIndex = null;
              lazyCodeToGroup = null;
            } else {
              while (sortedCodes.length > groupCapacity) {
                groupWidth <<= 1;
                groupCapacity = capacity(groupWidth);
              }

              lazyCodeToGroup = new Array(codeToValue.length);

              for (sortIndex = 0; sortIndex < sortedCodes.length; ++sortIndex) {
                encodedCode = sortedCodes[sortIndex];
                groups[sortIndex] = {key: codeToValue[encodedCode], value: initialValue()};
                lazyCodeToGroup[encodedCode] = sortIndex;
              }

              k = groups.length;
              groupIndex = k > 1 ? cr_index(n, groupCapacity) : null;

              if (groupIndex) {
                for (rowIndex = 0; rowIndex < n; ++rowIndex) {
                  groupIndex[rowIndex] = lazyCodeToGroup[codes[rowIndex]];
                }
              }
            }

            resetNeeded = true;

            var listenerIndex = filterListeners.indexOf(update);
            if (k > 1) {
              update = updateMany;
              reset = resetMany;
            } else if (k === 1) {
              update = updateOne;
              reset = resetOne;
              groupIndex = null;
            } else {
              update = cr_null;
              reset = cr_null;
              groupIndex = null;
            }
            filterListeners[listenerIndex] = update;
            return;
          }

          if(iterable) {
            n0old = n0;
            n0 = values.length - newValues.length;
            n1 = newValues.length;
          }

          var oldGroups = groups,
              reIndex = iterable ? [] : cr_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 = cr_null;
          if (resetNeeded) remove = initial = cr_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) : cr_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 && !isNaturallyOrderable(x1 = key(newValues[i1]))) ++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 && compareNaturalOrder(x0, x1) <= 0) {
              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 (compareNaturalOrder(x1, x) <= 0) {
              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 another dimension has filtered them out.
              // This gives groups full information on data life-cycle without paying for no-op filter checks.
              if (reduceMode === 'count') {
                if (!resetNeeded) {
                  g.value += 1;
                  if (hasOtherActiveDimensionFilters() && !filters.zeroExcept(j, offset, zero)) {
                    g.value -= 1;
                  }
                }
              } else if (reduceMode === 'metricSpec') {
                if (!resetNeeded) {
                  g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, j, 1);
                  if (hasOtherActiveDimensionFilters() && !filters.zeroExcept(j, offset, zero)) {
                    g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, j, -1);
                  }
                }
              } else {
                var rowRecord = getRecord(j);
                g.value = add(g.value, rowRecord, true);
                if (hasOtherActiveDimensionFilters() && !filters.zeroExcept(j, offset, zero)) g.value = remove(g.value, rowRecord, 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 = cr_null;
              reset = cr_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 = capacity(groupWidth);
            }
          }
        }

        function removeData(reIndex) {
          lazyCodeToGroup = null;
          if (k > 1 || iterable) {
            var oldK = k,
                oldGroups = groups,
                seenGroups = cr_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;
                }
              }
              groupIndex = groupIndex.slice(0, 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 = cr_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 = cr_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]];
                  if (reduceMode === 'count') {
                    g.value += 1;
                  } else if (reduceMode === 'metricSpec') {
                    g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, 1);
                  } else {
                    g.value = reduceAdd(g.value, getRecord(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]];
                  if (reduceMode === 'count') {
                    g.value -= 1;
                  } else if (reduceMode === 'metricSpec') {
                    g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, -1);
                  } else {
                    g.value = reduceRemove(g.value, getRecord(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]];
              if (reduceMode === 'count') {
                g.value += 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, 1);
              } else {
                g.value = reduceAdd(g.value, getRecord(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]];
              if (reduceMode === 'count') {
                g.value -= 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, -1);
              } else {
                g.value = reduceRemove(g.value, getRecord(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)) {
              if (reduceMode === 'count') {
                g.value += 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, 1);
              } else {
                g.value = reduceAdd(g.value, getRecord(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)) {
              if (reduceMode === 'count') {
                g.value -= 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, k, -1);
              } else {
                g.value = reduceRemove(g.value, getRecord(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,
              applyFilteredRemovals = hasOtherActiveDimensionFilters();

          // 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]];
                if (reduceMode === 'count') {
                  g.value += 1;
                } else if (reduceMode === 'metricSpec') {
                  g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, 1);
                } else {
                  var iterableRecord = getRecord(i);
                  g.value = reduceAdd(g.value, iterableRecord, true, j);
                }
              }
            }
            if (!applyFilteredRemovals) {
              return;
            }
            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]];
                  if (reduceMode === 'count') {
                    g.value -= 1;
                  } else if (reduceMode === 'metricSpec') {
                    g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, -1);
                  } else {
                    var filteredIterableRecord = getRecord(i);
                    g.value = reduceRemove(g.value, filteredIterableRecord, false, j);
                  }
                }
              }
            }
            return;
          }

          for (i = 0; i < n; ++i) {
            g = groups[groupIndex[i]];
            if (reduceMode === 'count') {
              g.value += 1;
            } else if (reduceMode === 'metricSpec') {
              g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, 1);
            } else {
              g.value = reduceAdd(g.value, getRecord(i), true);
            }
          }
          if (!applyFilteredRemovals) {
            return;
          }
          for (i = 0; i < n; ++i) {
            if (!filters.zeroExcept(i, offset, zero)) {
              g = groups[groupIndex[i]];
              if (reduceMode === 'count') {
                g.value -= 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, -1);
              } else {
                g.value = reduceRemove(g.value, getRecord(i), false);
              }
            }
          }
        }

        // Recomputes the group reduce values from scratch.
        // This function is only used when the cardinality is 1.
        function resetOne() {
          var i,
              applyFilteredRemovals = hasOtherActiveDimensionFilters(),
              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) {
            if (reduceMode === 'count') {
              g.value += 1;
            } else if (reduceMode === 'metricSpec') {
              g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, 1);
            } else {
              g.value = reduceAdd(g.value, getRecord(i), true);
            }
          }

          if (!applyFilteredRemovals) {
            return;
          }
          for (i = 0; i < n; ++i) {
            if (!filters.zeroExcept(i, offset, zero)) {
              if (reduceMode === 'count') {
                g.value -= 1;
              } else if (reduceMode === 'metricSpec') {
                g.value = applyReduceMetricSpec(g.value, reduceMetricSpec, i, -1);
              } else {
                g.value = reduceRemove(g.value, getRecord(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;
          reduceMetricSpec = resolveReduceMetricSpec(add, remove, initial);
          reduceMode = null;
          if (reduceMetricSpec) {
            reduceMode = 'metricSpec';
          }
          resetNeeded = true;
          return group;
        }

        // A convenience method for reducing by count.
        function reduceCount() {
          reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, cr_zero);
          reduceMode = 'count';
          return group;
        }

        // A convenience method for reducing by sum(value).
        function reduceSum(value) {
          return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), cr_zero);
        }

        // Sets the reduce order, using the specified accessor.
        function order(value) {
          select = h.by(valueOf);
          heap = h$1.by(valueOf);
          function valueOf(d) { return value(d.value); }
          return group;
        }

        // A convenience method for natural ordering by reduce value.
        function orderNatural() {
          return order(cr_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);
          i = dimensionGroups.indexOf(group);
          if (i >= 0) dimensionGroups.splice(i, 1);
          unregisterResetListener(markResetNeeded);
          return group;
        }

        return reduceCount().orderNatural();
      }

      // A convenience function for generating a singleton group.
      function groupAll() {
        var g = group(cr_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,
          reduceMetricSpec = null,
          reduceMode = null,
          resetNeeded = true,
          markResetNeeded = registerResetListener(function() {
            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);

      // Incorporates the specified new values into this group.
      function add(newData, n0) {
        var i,
            applyFilteredRemovals = hasAnyActiveDimensionFilters();

        if (resetNeeded) return;

        // Cycle through all the values.
        for (i = n0; i < n; ++i) {
          if (reduceMode === 'count') {
            reduceValue += 1;
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue -= 1;
            }
          } else if (reduceMode === 'metricSpec') {
            reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, i, 1);
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, i, -1);
            }
          } else {
            var rowRecord = getRecord(i);

            // Add all values all the time.
            reduceValue = reduceAdd(reduceValue, rowRecord, true);

            // Remove the value if filtered.
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue = reduceRemove(reduceValue, rowRecord, 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])) {
            if (reduceMode === 'count') {
              reduceValue += 1;
            } else if (reduceMode === 'metricSpec') {
              reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, k, 1);
            } else {
              reduceValue = reduceAdd(reduceValue, getRecord(k), notFilter);
            }
          }
        }

        // Remove the removed values.
        for (i = 0, n = removed.length; i < n; ++i) {
          if (filters.only(k = removed[i], filterOffset, filterOne)) {
            if (reduceMode === 'count') {
              reduceValue -= 1;
            } else if (reduceMode === 'metricSpec') {
              reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, k, -1);
            } else {
              reduceValue = reduceRemove(reduceValue, getRecord(k), notFilter);
            }
          }
        }
      }

      // Recomputes the group reduce value from scratch.
      function reset() {
        var i,
            applyFilteredRemovals = hasAnyActiveDimensionFilters();

        reduceValue = reduceInitial();

        // Cycle through all the values.
        for (i = 0; i < n; ++i) {
          if (reduceMode === 'count') {
            reduceValue += 1;
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue -= 1;
            }
          } else if (reduceMode === 'metricSpec') {
            reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, i, 1);
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue = applyReduceMetricSpec(reduceValue, reduceMetricSpec, i, -1);
            }
          } else {
            var rowRecord = getRecord(i);

            // Add all values all the time.
            reduceValue = reduceAdd(reduceValue, rowRecord, true);

            // Remove the value if it is filtered.
            if (applyFilteredRemovals && !filters.zero(i)) {
              reduceValue = reduceRemove(reduceValue, rowRecord, 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;
        reduceMetricSpec = resolveReduceMetricSpec(add, remove, initial);
        reduceMode = null;
        if (reduceMetricSpec) {
          reduceMode = 'metricSpec';
        }
        resetNeeded = true;
        return group;
      }

      // A convenience method for reducing by count.
      function reduceCount() {
        reduce(xfilterReduce.reduceIncrement, xfilterReduce.reduceDecrement, cr_zero);
        reduceMode = 'count';
        return group;
      }

      // A convenience method for reducing by sum(value).
      function reduceSum(value) {
        return reduce(xfilterReduce.reduceAdd(value), xfilterReduce.reduceSubtract(value), cr_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);
        unregisterResetListener(markResetNeeded);
        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(){
      materializeAllRecords();
      return data;
    }

    // Returns row data with all dimension filters applied, except for filters in ignore_dimensions
    function allFiltered(ignore_dimensions) {
      var array = [],
          i = 0,
          mask = maskForDimensions(ignore_dimensions || []);

        for (i = 0; i < n; i++) {
          if (filters.zeroExceptMask(i, mask)) {
            array.push(getRecord(i));
          }
        }

        return array;
    }

    function allFilteredIndexes(ignore_dimensions) {
      var array = [],
          i = 0,
          mask = maskForDimensions(ignore_dimensions || []);

      for (i = 0; i < n; i++) {
        if (filters.zeroExceptMask(i, mask)) {
          array.push(i);
        }
      }

      return array;
    }

    function takeColumns(rowIndexes, fields) {
      var selectedFields = fields && fields.length ? fields.slice() : null;
      var columns = {};
      var rowCount = rowIndexes ? rowIndexes.length : 0;
      var fieldIndex;
      var rowIndex;

      if (!selectedFields) {
        return {
          columns: columns,
          fields: [],
          length: rowCount
        };
      }

      for (fieldIndex = 0; fieldIndex < selectedFields.length; ++fieldIndex) {
        columns[selectedFields[fieldIndex]] = new Array(rowCount);
      }

      for (rowIndex = 0; rowIndex < rowCount; ++rowIndex) {
        for (fieldIndex = 0; fieldIndex < selectedFields.length; ++fieldIndex) {
          var field = selectedFields[fieldIndex];
          columns[field][rowIndex] = getFieldValue(rowIndexes[rowIndex], field);
        }
      }

      return {
        columns: columns,
        fields: selectedFields,
        length: rowCount
      };
    }

    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 cr_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 cr_range(n) {
    var range = cr_index(n, n);
    for (var i = -1; ++i < n;) range[i] = i;
    return range;
  }

  function capacity(w) {
    return w === 8
        ? 0x100 : w === 16
        ? 0x10000
        : 0x100000000;
  }

  const version = "3.0.2";

  crossfilter.version = version;

  return crossfilter;

}));