@uwdata/mosaic-plot 0.8.0 → 0.10.0

package/dist/mosaic-plot.js

@@ -155,8 +155,8 @@ var require_interval_tree = __commonJS({
       a2.rightPoints = b.rightPoints;
       a2.count = b.count;
     }
-    function rebuild(node, intervals) {
-      var ntree = createIntervalTree(intervals);
+    function rebuild(node, intervals2) {
+      var ntree = createIntervalTree(intervals2);
       node.mid = ntree.mid;
       node.left = ntree.left;
       node.right = ntree.right;
@@ -165,18 +165,18 @@ var require_interval_tree = __commonJS({
       node.count = ntree.count;
     }
     function rebuildWithInterval(node, interval2) {
-      var intervals = node.intervals([]);
-      intervals.push(interval2);
-      rebuild(node, intervals);
+      var intervals2 = node.intervals([]);
+      intervals2.push(interval2);
+      rebuild(node, intervals2);
     }
     function rebuildWithoutInterval(node, interval2) {
-      var intervals = node.intervals([]);
-      var idx = intervals.indexOf(interval2);
+      var intervals2 = node.intervals([]);
+      var idx = intervals2.indexOf(interval2);
       if (idx < 0) {
         return NOT_FOUND;
       }
-      intervals.splice(idx, 1);
-      rebuild(node, intervals);
+      intervals2.splice(idx, 1);
+      rebuild(node, intervals2);
       return SUCCESS;
     }
     proto.intervals = function(result) {
@@ -393,21 +393,21 @@ var require_interval_tree = __commonJS({
       }
       return a2[0] - b[0];
     }
-    function createIntervalTree(intervals) {
-      if (intervals.length === 0) {
+    function createIntervalTree(intervals2) {
+      if (intervals2.length === 0) {
         return null;
       }
       var pts = [];
-      for (var i = 0; i < intervals.length; ++i) {
-        pts.push(intervals[i][0], intervals[i][1]);
+      for (var i = 0; i < intervals2.length; ++i) {
+        pts.push(intervals2[i][0], intervals2[i][1]);
       }
       pts.sort(compareNumbers);
       var mid2 = pts[pts.length >> 1];
       var leftIntervals = [];
       var rightIntervals = [];
       var centerIntervals = [];
-      for (var i = 0; i < intervals.length; ++i) {
-        var s2 = intervals[i];
+      for (var i = 0; i < intervals2.length; ++i) {
+        var s2 = intervals2[i];
         if (s2[1] < mid2) {
           leftIntervals.push(s2);
         } else if (mid2 < s2[0]) {
@@ -475,11 +475,11 @@ var require_interval_tree = __commonJS({
         return [];
       }
     });
-    function createWrapper(intervals) {
-      if (!intervals || intervals.length === 0) {
+    function createWrapper(intervals2) {
+      if (!intervals2 || intervals2.length === 0) {
         return new IntervalTree2(null);
       }
-      return new IntervalTree2(createIntervalTree(intervals));
+      return new IntervalTree2(createIntervalTree(intervals2));
     }
   }
 });
@@ -608,7 +608,6 @@ var MosaicClient = class {
    * @returns {this}
    */
   queryError(error) {
-    console.error(error);
     return this;
   }
   /**
@@ -632,7 +631,7 @@ var MosaicClient = class {
   /**
    * Requests a client update.
    * For example to (re-)render an interface component.
-   * 
+   *
    * @returns {this | Promise<any>}
    */
   update() {
@@ -696,16 +695,24 @@ function __await(v2) {
 function __asyncGenerator(thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+  return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
     return this;
   }, i;
-  function verb(n) {
-    if (g[n]) i[n] = function(v2) {
-      return new Promise(function(a2, b) {
-        q.push([n, v2, a2, b]) > 1 || resume(n, v2);
-      });
+  function awaitReturn(f) {
+    return function(v2) {
+      return Promise.resolve(v2).then(f, reject);
     };
   }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v2) {
+        return new Promise(function(a2, b) {
+          q.push([n, v2, a2, b]) > 1 || resume(n, v2);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
   function resume(n, v2) {
     try {
       step(g[n](v2));
@@ -1325,26 +1332,26 @@ var IntervalUnit;
   IntervalUnit2[IntervalUnit2["MONTH_DAY_NANO"] = 2] = "MONTH_DAY_NANO";
 })(IntervalUnit || (IntervalUnit = {}));
 
-// ../../node_modules/flatbuffers/mjs/constants.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/constants.js
 var SIZEOF_SHORT = 2;
 var SIZEOF_INT = 4;
 var FILE_IDENTIFIER_LENGTH = 4;
 var SIZE_PREFIX_LENGTH = 4;
 
-// ../../node_modules/flatbuffers/mjs/utils.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/utils.js
 var int32 = new Int32Array(2);
 var float32 = new Float32Array(int32.buffer);
 var float64 = new Float64Array(int32.buffer);
 var isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
 
-// ../../node_modules/flatbuffers/mjs/encoding.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/encoding.js
 var Encoding;
 (function(Encoding2) {
   Encoding2[Encoding2["UTF8_BYTES"] = 1] = "UTF8_BYTES";
   Encoding2[Encoding2["UTF16_STRING"] = 2] = "UTF16_STRING";
 })(Encoding || (Encoding = {}));
 
-// ../../node_modules/flatbuffers/mjs/byte-buffer.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/byte-buffer.js
 var ByteBuffer = class _ByteBuffer {
   /**
    * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
@@ -1588,7 +1595,7 @@ var ByteBuffer = class _ByteBuffer {
   }
 };
 
-// ../../node_modules/flatbuffers/mjs/builder.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/builder.js
 var Builder = class _Builder {
   /**
    * Create a FlatBufferBuilder.
@@ -2028,9 +2035,22 @@ var Builder = class _Builder {
     this.addInt8(0);
     this.startVector(1, utf8.length, 1);
     this.bb.setPosition(this.space -= utf8.length);
-    for (let i = 0, offset2 = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
-      bytes[offset2++] = utf8[i];
+    this.bb.bytes().set(utf8, this.space);
+    return this.endVector();
+  }
+  /**
+   * Create a byte vector.
+   *
+   * @param v The bytes to add
+   * @returns The offset in the buffer where the byte vector starts
+   */
+  createByteVector(v2) {
+    if (v2 === null || v2 === void 0) {
+      return 0;
     }
+    this.startVector(1, v2.length, 1);
+    this.bb.setPosition(this.space -= v2.length);
+    this.bb.bytes().set(v2, this.space);
     return this.endVector();
   }
   /**
@@ -3633,9 +3653,9 @@ var BufferType;
 // ../../node_modules/apache-arrow/util/vector.mjs
 var vector_exports = {};
 __export(vector_exports, {
-  clampIndex: () => clampIndex,
   clampRange: () => clampRange,
-  createElementComparator: () => createElementComparator
+  createElementComparator: () => createElementComparator,
+  wrapIndex: () => wrapIndex
 });
 
 // ../../node_modules/apache-arrow/util/pretty.mjs
@@ -3676,9 +3696,23 @@ var bn_exports = {};
 __export(bn_exports, {
   BN: () => BN,
   bigNumToBigInt: () => bigNumToBigInt,
+  bigNumToNumber: () => bigNumToNumber,
   bigNumToString: () => bigNumToString,
   isArrowBigNumSymbol: () => isArrowBigNumSymbol
 });
+
+// ../../node_modules/apache-arrow/util/bigint.mjs
+function bigIntToNumber(number7) {
+  if (typeof number7 === "bigint" && (number7 < Number.MIN_SAFE_INTEGER || number7 > Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError(`${number7} is not safe to convert to a number.`);
+  }
+  return Number(number7);
+}
+function divideBigInts(number7, divisor) {
+  return bigIntToNumber(number7 / divisor) + bigIntToNumber(number7 % divisor) / bigIntToNumber(divisor);
+}
+
+// ../../node_modules/apache-arrow/util/bn.mjs
 var isArrowBigNumSymbol = Symbol.for("isArrowBigNum");
 function BigNum(x3, ...xs) {
   if (xs.length === 0) {
@@ -3690,8 +3724,8 @@ BigNum.prototype[isArrowBigNumSymbol] = true;
 BigNum.prototype.toJSON = function() {
   return `"${bigNumToString(this)}"`;
 };
-BigNum.prototype.valueOf = function() {
-  return bigNumToNumber(this);
+BigNum.prototype.valueOf = function(scale3) {
+  return bigNumToNumber(this, scale3);
 };
 BigNum.prototype.toString = function() {
   return bigNumToString(this);
@@ -3722,25 +3756,34 @@ Object.setPrototypeOf(DecimalBigNum.prototype, Object.create(Uint32Array.prototy
 Object.assign(SignedBigNum.prototype, BigNum.prototype, { "constructor": SignedBigNum, "signed": true, "TypedArray": Int32Array, "BigIntArray": BigInt64Array });
 Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { "constructor": UnsignedBigNum, "signed": false, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
 Object.assign(DecimalBigNum.prototype, BigNum.prototype, { "constructor": DecimalBigNum, "signed": true, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
-function bigNumToNumber(bn) {
-  const { buffer, byteOffset, length: length4, "signed": signed } = bn;
-  const words = new BigUint64Array(buffer, byteOffset, length4);
+var TWO_TO_THE_64 = BigInt(4294967296) * BigInt(4294967296);
+var TWO_TO_THE_64_MINUS_1 = TWO_TO_THE_64 - BigInt(1);
+function bigNumToNumber(bn, scale3) {
+  const { buffer, byteOffset, byteLength, "signed": signed } = bn;
+  const words = new BigUint64Array(buffer, byteOffset, byteLength / 8);
   const negative2 = signed && words.at(-1) & BigInt(1) << BigInt(63);
-  let number7 = negative2 ? BigInt(1) : BigInt(0);
-  let i = BigInt(0);
-  if (!negative2) {
+  let number7 = BigInt(0);
+  let i = 0;
+  if (negative2) {
     for (const word of words) {
-      number7 += word * (BigInt(1) << BigInt(32) * i++);
+      number7 |= (word ^ TWO_TO_THE_64_MINUS_1) * (BigInt(1) << BigInt(64 * i++));
     }
+    number7 *= BigInt(-1);
+    number7 -= BigInt(1);
   } else {
     for (const word of words) {
-      number7 += ~word * (BigInt(1) << BigInt(32) * i++);
+      number7 |= word * (BigInt(1) << BigInt(64 * i++));
     }
-    number7 *= BigInt(-1);
   }
-  return number7;
+  if (typeof scale3 === "number") {
+    const denominator = BigInt(Math.pow(10, scale3));
+    const quotient = number7 / denominator;
+    const remainder = number7 % denominator;
+    return bigIntToNumber(quotient) + bigIntToNumber(remainder) / bigIntToNumber(denominator);
+  }
+  return bigIntToNumber(number7);
 }
-var bigNumToString = (a2) => {
+function bigNumToString(a2) {
   if (a2.byteLength === 8) {
     const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
     return `${bigIntArray[0]}`;
@@ -3763,15 +3806,15 @@ var bigNumToString = (a2) => {
   }
   const negated = unsignedBigNumToString(array4);
   return `-${negated}`;
-};
-var bigNumToBigInt = (a2) => {
+}
+function bigNumToBigInt(a2) {
   if (a2.byteLength === 8) {
     const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
     return bigIntArray[0];
   } else {
     return bigNumToString(a2);
   }
-};
+}
 function unsignedBigNumToString(a2) {
   let digits = "";
   const base64 = new Uint32Array(2);
@@ -3828,14 +3871,6 @@ var BN = class _BN {
   }
 };
 
-// ../../node_modules/apache-arrow/util/bigint.mjs
-function bigIntToNumber(number7) {
-  if (typeof number7 === "bigint" && (number7 < Number.MIN_SAFE_INTEGER || number7 > Number.MAX_SAFE_INTEGER)) {
-    throw new TypeError(`${number7} is not safe to convert to a number.`);
-  }
-  return Number(number7);
-}
-
 // ../../node_modules/apache-arrow/type.mjs
 var _a;
 var _b;
@@ -4210,11 +4245,13 @@ var Date_ = class extends DataType {
   toString() {
     return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
   }
+  get ArrayType() {
+    return this.unit === DateUnit.DAY ? Int32Array : BigInt64Array;
+  }
 };
 _l = Symbol.toStringTag;
 Date_[_l] = ((proto) => {
   proto.unit = null;
-  proto.ArrayType = Int32Array;
   return proto[Symbol.toStringTag] = "Date";
 })(Date_.prototype);
 var Time_ = class extends DataType {
@@ -4256,7 +4293,7 @@ _o = Symbol.toStringTag;
 Timestamp_[_o] = ((proto) => {
   proto.unit = null;
   proto.timezone = null;
-  proto.ArrayType = Int32Array;
+  proto.ArrayType = BigInt64Array;
   return proto[Symbol.toStringTag] = "Timestamp";
 })(Timestamp_.prototype);
 var Interval_ = class extends DataType {
@@ -4428,9 +4465,9 @@ Map_[_w] = ((proto) => {
 })(Map_.prototype);
 var getId = /* @__PURE__ */ ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);
 var Dictionary = class extends DataType {
-  constructor(dictionary, indices, id2, isOrdered2) {
+  constructor(dictionary, indices2, id2, isOrdered2) {
     super(Type2.Dictionary);
-    this.indices = indices;
+    this.indices = indices2;
     this.dictionary = dictionary;
     this.isOrdered = isOrdered2 || false;
     this.id = id2 == null ? getId() : bigIntToNumber(id2);
@@ -4461,10 +4498,6 @@ function strideForType(type2) {
   switch (type2.typeId) {
     case Type2.Decimal:
       return type2.bitWidth / 32;
-    case Type2.Timestamp:
-      return 2;
-    case Type2.Date:
-      return 1 + t.unit;
     case Type2.Interval:
       return 1 + t.unit;
     case Type2.FixedSizeList:
@@ -4931,19 +4964,7 @@ function wrapSet(fn) {
   };
 }
 var setEpochMsToDays = (data, index2, epochMs) => {
-  data[index2] = Math.trunc(epochMs / 864e5);
-};
-var setEpochMsToMillisecondsLong = (data, index2, epochMs) => {
-  data[index2] = Math.trunc(epochMs % 4294967296);
-  data[index2 + 1] = Math.trunc(epochMs / 4294967296);
-};
-var setEpochMsToMicrosecondsLong = (data, index2, epochMs) => {
-  data[index2] = Math.trunc(epochMs * 1e3 % 4294967296);
-  data[index2 + 1] = Math.trunc(epochMs * 1e3 / 4294967296);
-};
-var setEpochMsToNanosecondsLong = (data, index2, epochMs) => {
-  data[index2] = Math.trunc(epochMs * 1e6 % 4294967296);
-  data[index2 + 1] = Math.trunc(epochMs * 1e6 / 4294967296);
+  data[index2] = Math.floor(epochMs / 864e5);
 };
 var setVariableWidthBytes = (values2, valueOffsets, index2, value) => {
   if (index2 + 1 < valueOffsets.length) {
@@ -4978,7 +4999,7 @@ var setDateDay = ({ values: values2 }, index2, value) => {
   setEpochMsToDays(values2, index2, value.valueOf());
 };
 var setDateMillisecond = ({ values: values2 }, index2, value) => {
-  setEpochMsToMillisecondsLong(values2, index2 * 2, value.valueOf());
+  values2[index2] = BigInt(value);
 };
 var setFixedSizeBinary = ({ stride, values: values2 }, index2, value) => {
   values2.set(value.subarray(0, stride), stride * index2);
@@ -4988,10 +5009,18 @@ var setUtf8 = ({ values: values2, valueOffsets }, index2, value) => setVariableW
 var setDate = (data, index2, value) => {
   data.type.unit === DateUnit.DAY ? setDateDay(data, index2, value) : setDateMillisecond(data, index2, value);
 };
-var setTimestampSecond = ({ values: values2 }, index2, value) => setEpochMsToMillisecondsLong(values2, index2 * 2, value / 1e3);
-var setTimestampMillisecond = ({ values: values2 }, index2, value) => setEpochMsToMillisecondsLong(values2, index2 * 2, value);
-var setTimestampMicrosecond = ({ values: values2 }, index2, value) => setEpochMsToMicrosecondsLong(values2, index2 * 2, value);
-var setTimestampNanosecond = ({ values: values2 }, index2, value) => setEpochMsToNanosecondsLong(values2, index2 * 2, value);
+var setTimestampSecond = ({ values: values2 }, index2, value) => {
+  values2[index2] = BigInt(value / 1e3);
+};
+var setTimestampMillisecond = ({ values: values2 }, index2, value) => {
+  values2[index2] = BigInt(value);
+};
+var setTimestampMicrosecond = ({ values: values2 }, index2, value) => {
+  values2[index2] = BigInt(value * 1e3);
+};
+var setTimestampNanosecond = ({ values: values2 }, index2, value) => {
+  values2[index2] = BigInt(value * 1e6);
+};
 var setTimestamp = (data, index2, value) => {
   switch (data.type.unit) {
     case TimeUnit.SECOND:
@@ -5296,12 +5325,6 @@ function wrapGet(fn) {
   return (data, _1) => data.getValid(_1) ? fn(data, _1) : null;
 }
 var epochDaysToMs = (data, index2) => 864e5 * data[index2];
-var epochMillisecondsLongToMs = (data, index2) => 4294967296 * data[index2 + 1] + (data[index2] >>> 0);
-var epochMicrosecondsLongToMs = (data, index2) => 4294967296 * (data[index2 + 1] / 1e3) + (data[index2] >>> 0) / 1e3;
-var epochNanosecondsLongToMs = (data, index2) => 4294967296 * (data[index2 + 1] / 1e6) + (data[index2] >>> 0) / 1e6;
-var epochMillisecondsToDate = (epochMs) => new Date(epochMs);
-var epochDaysToDate = (data, index2) => epochMillisecondsToDate(epochDaysToMs(data, index2));
-var epochMillisecondsLongToDate = (data, index2) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index2));
 var getNull = (_data, _index) => null;
 var getVariableWidthBytes = (values2, valueOffsets, index2) => {
   if (index2 + 1 >= valueOffsets.length) {
@@ -5316,8 +5339,8 @@ var getBool = ({ offset: offset2, values: values2 }, index2) => {
   const byte = values2[idx >> 3];
   return (byte & 1 << idx % 8) !== 0;
 };
-var getDateDay = ({ values: values2 }, index2) => epochDaysToDate(values2, index2);
-var getDateMillisecond = ({ values: values2 }, index2) => epochMillisecondsLongToDate(values2, index2 * 2);
+var getDateDay = ({ values: values2 }, index2) => epochDaysToMs(values2, index2);
+var getDateMillisecond = ({ values: values2 }, index2) => bigIntToNumber(values2[index2]);
 var getNumeric = ({ stride, values: values2 }, index2) => values2[stride * index2];
 var getFloat16 = ({ stride, values: values2 }, index2) => uint16ToFloat64(values2[stride * index2]);
 var getBigInts = ({ values: values2 }, index2) => values2[index2];
@@ -5330,10 +5353,10 @@ var getUtf8 = ({ values: values2, valueOffsets }, index2) => {
 var getInt = ({ values: values2 }, index2) => values2[index2];
 var getFloat = ({ type: type2, values: values2 }, index2) => type2.precision !== Precision.HALF ? values2[index2] : uint16ToFloat64(values2[index2]);
 var getDate = (data, index2) => data.type.unit === DateUnit.DAY ? getDateDay(data, index2) : getDateMillisecond(data, index2);
-var getTimestampSecond = ({ values: values2 }, index2) => 1e3 * epochMillisecondsLongToMs(values2, index2 * 2);
-var getTimestampMillisecond = ({ values: values2 }, index2) => epochMillisecondsLongToMs(values2, index2 * 2);
-var getTimestampMicrosecond = ({ values: values2 }, index2) => epochMicrosecondsLongToMs(values2, index2 * 2);
-var getTimestampNanosecond = ({ values: values2 }, index2) => epochNanosecondsLongToMs(values2, index2 * 2);
+var getTimestampSecond = ({ values: values2 }, index2) => 1e3 * bigIntToNumber(values2[index2]);
+var getTimestampMillisecond = ({ values: values2 }, index2) => bigIntToNumber(values2[index2]);
+var getTimestampMicrosecond = ({ values: values2 }, index2) => divideBigInts(values2[index2], BigInt(1e3));
+var getTimestampNanosecond = ({ values: values2 }, index2) => divideBigInts(values2[index2], BigInt(1e6));
 var getTimestamp = (data, index2) => {
   switch (data.type.unit) {
     case TimeUnit.SECOND:
@@ -5482,12 +5505,18 @@ var instance2 = new GetVisitor();
 // ../../node_modules/apache-arrow/row/map.mjs
 var kKeys = Symbol.for("keys");
 var kVals = Symbol.for("vals");
+var kKeysAsStrings = Symbol.for("kKeysAsStrings");
+var _kKeysAsStrings = Symbol.for("_kKeysAsStrings");
 var MapRow = class {
   constructor(slice4) {
     this[kKeys] = new Vector([slice4.children[0]]).memoize();
     this[kVals] = slice4.children[1];
     return new Proxy(this, new MapRowProxyHandler());
   }
+  /** @ignore */
+  get [kKeysAsStrings]() {
+    return this[_kKeysAsStrings] || (this[_kKeysAsStrings] = Array.from(this[kKeys].toArray(), String));
+  }
   [Symbol.iterator]() {
     return new MapRowIterator(this[kKeys], this[kVals]);
   }
@@ -5549,13 +5578,13 @@ var MapRowProxyHandler = class {
     return true;
   }
   ownKeys(row) {
-    return row[kKeys].toArray().map(String);
+    return row[kKeysAsStrings];
   }
   has(row, key) {
-    return row[kKeys].includes(key);
+    return row[kKeysAsStrings].includes(key);
   }
   getOwnPropertyDescriptor(row, key) {
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       return { writable: true, enumerable: true, configurable: true };
     }
@@ -5565,7 +5594,7 @@ var MapRowProxyHandler = class {
     if (Reflect.has(row, key)) {
       return row[key];
     }
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       const val = instance2.visit(Reflect.get(row, kVals), idx);
       Reflect.set(row, key, val);
@@ -5573,7 +5602,7 @@ var MapRowProxyHandler = class {
     }
   }
   set(row, key, val) {
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       instance.visit(Reflect.get(row, kVals), idx, val);
       return Reflect.set(row, key, val);
@@ -5586,15 +5615,11 @@ var MapRowProxyHandler = class {
 Object.defineProperties(MapRow.prototype, {
   [Symbol.toStringTag]: { enumerable: false, configurable: false, value: "Row" },
   [kKeys]: { writable: true, enumerable: false, configurable: false, value: null },
-  [kVals]: { writable: true, enumerable: false, configurable: false, value: null }
+  [kVals]: { writable: true, enumerable: false, configurable: false, value: null },
+  [_kKeysAsStrings]: { writable: true, enumerable: false, configurable: false, value: null }
 });
 
 // ../../node_modules/apache-arrow/util/vector.mjs
-function clampIndex(source, index2, then) {
-  const length4 = source.length;
-  const adjust = index2 > -1 ? index2 : length4 + index2 % length4;
-  return then ? then(source, adjust) : adjust;
-}
 var tmp;
 function clampRange(source, begin, end, then) {
   const { length: len = 0 } = source;
@@ -5606,6 +5631,7 @@ function clampRange(source, begin, end, then) {
   rhs > len && (rhs = len);
   return then ? then(source, lhs, rhs) : [lhs, rhs];
 }
+var wrapIndex = (index2, len) => index2 < 0 ? len + index2 : index2;
 var isNaNFast = (value) => value !== value;
 function createElementComparator(search) {
   const typeofSearch = typeof search;
@@ -5894,7 +5920,10 @@ var Data = class _Data {
     let nullCount = this._nullCount;
     let nullBitmap;
     if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {
-      this._nullCount = nullCount = this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
+      this._nullCount = nullCount = nullBitmap.length === 0 ? (
+        // no null bitmap, so all values are valid
+        0
+      ) : this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
     }
     return nullCount;
   }
@@ -5956,12 +5985,14 @@ var Data = class _Data {
         nullBitmap = new Uint8Array((offset2 + length4 + 63 & ~63) >> 3).fill(255);
         if (this.nullCount > 0) {
           nullBitmap.set(truncateBitmap(offset2, length4, this.nullBitmap), 0);
+          Object.assign(this, { nullBitmap });
+        } else {
+          Object.assign(this, { nullBitmap, _nullCount: 0 });
         }
-        Object.assign(this, { nullBitmap, _nullCount: -1 });
       }
       const byte = nullBitmap[byteOffset];
       prev = (byte & mask) !== 0;
-      value ? nullBitmap[byteOffset] = byte | mask : nullBitmap[byteOffset] = byte & ~mask;
+      nullBitmap[byteOffset] = value ? byte | mask : byte & ~mask;
     }
     if (prev !== !!value) {
       this._nullCount = this.nullCount + (value ? -1 : 1);
@@ -6402,7 +6433,9 @@ var IteratorVisitor = class extends Visitor {
 };
 function vectorIterator(vector2) {
   const { type: type2 } = vector2;
-  if (vector2.nullCount === 0 && vector2.stride === 1 && (type2.typeId === Type2.Timestamp || type2 instanceof Int_ && type2.bitWidth !== 64 || type2 instanceof Time_ && type2.bitWidth !== 64 || type2 instanceof Float && type2.precision !== Precision.HALF)) {
+  if (vector2.nullCount === 0 && vector2.stride === 1 && // Don't defer to native iterator for timestamps since Numbers are expected
+  // (DataType.isTimestamp(type)) && type.unit === TimeUnit.MILLISECOND ||
+  (DataType.isInt(type2) && type2.bitWidth !== 64 || DataType.isTime(type2) && type2.bitWidth !== 64 || DataType.isFloat(type2) && type2.precision !== Precision.HALF)) {
     return new ChunkedIterator(vector2.data.length, (chunkIndex) => {
       const data = vector2.data[chunkIndex];
       return data.values.subarray(0, data.length)[Symbol.iterator]();
@@ -6576,6 +6609,13 @@ var Vector = class _Vector {
   get(index2) {
     return null;
   }
+  /**
+   * Get an element value by position.
+   * @param index The index of the element to read. A negative index will count back from the last element.
+   */
+  at(index2) {
+    return this.get(wrapIndex(index2, this.length));
+  }
   /**
    * Set an element value by position.
    * @param index The index of the element to write.
@@ -7853,8 +7893,8 @@ var AsyncByteStreamSource = class {
       return (yield this.next(size, "peek")).value;
     });
   }
-  next(size, cmd = "read") {
-    return __awaiter(this, void 0, void 0, function* () {
+  next(size_1) {
+    return __awaiter(this, arguments, void 0, function* (size, cmd = "read") {
       return yield this.source.next({ cmd, size });
     });
   }
@@ -8595,9 +8635,9 @@ var DictionaryBuilder = class extends Builder2 {
     return this.indices.isValid(value);
   }
   setValid(index2, valid2) {
-    const indices = this.indices;
-    valid2 = indices.setValid(index2, valid2);
-    this.length = indices.length;
+    const indices2 = this.indices;
+    valid2 = indices2.setValid(index2, valid2);
+    this.length = indices2.length;
     return valid2;
   }
   setValue(index2, value) {
@@ -9431,6 +9471,14 @@ var Table = class _Table {
   get(index2) {
     return null;
   }
+  /**
+    * Get an element value by position.
+    * @param index The index of the element to read. A negative index will count back from the last element.
+    */
+  // @ts-ignore
+  at(index2) {
+    return this.get(wrapIndex(index2, this.numRows));
+  }
   /**
    * Set an element value by position.
    *
@@ -9573,16 +9621,16 @@ var Table = class _Table {
   }
   assign(other) {
     const fields = this.schema.fields;
-    const [indices, oldToNew] = other.schema.fields.reduce((memo2, f2, newIdx) => {
-      const [indices2, oldToNew2] = memo2;
+    const [indices2, oldToNew] = other.schema.fields.reduce((memo2, f2, newIdx) => {
+      const [indices3, oldToNew2] = memo2;
       const i = fields.findIndex((f) => f.name === f2.name);
-      ~i ? oldToNew2[i] = newIdx : indices2.push(newIdx);
+      ~i ? oldToNew2[i] = newIdx : indices3.push(newIdx);
       return memo2;
     }, [[], []]);
     const schema = this.schema.assign(other.schema);
     const columns = [
       ...fields.map((_, i) => [i, oldToNew[i]]).map(([i, j]) => j === void 0 ? this.getChildAt(i) : other.getChildAt(j)),
-      ...indices.map((i) => other.getChildAt(i))
+      ...indices2.map((i) => other.getChildAt(i))
     ].filter(Boolean);
     return new _Table(...distributeVectorsIntoRecordBatches(schema, columns));
   }
@@ -9668,7 +9716,7 @@ var RecordBatch2 = class _RecordBatch {
     return this.data.nullCount;
   }
   /**
-   * Check whether an element is null.
+   * Check whether an row is null.
    * @param index The index at which to read the validity bitmap.
    */
   isValid(index2) {
@@ -9676,14 +9724,21 @@ var RecordBatch2 = class _RecordBatch {
   }
   /**
    * Get a row by position.
-   * @param index The index of the element to read.
+   * @param index The index of the row to read.
    */
   get(index2) {
     return instance2.visit(this.data, index2);
   }
+  /**
+    * Get a row value by position.
+    * @param index The index of the row to read. A negative index will count back from the last row.
+    */
+  at(index2) {
+    return this.get(wrapIndex(index2, this.numRows));
+  }
   /**
    * Set a row by position.
-   * @param index The index of the element to write.
+   * @param index The index of the row to write.
    * @param value The value to set.
    */
   set(index2, value) {
@@ -9720,7 +9775,7 @@ var RecordBatch2 = class _RecordBatch {
   /**
    * Return a zero-copy sub-section of this RecordBatch.
    * @param start The beginning of the specified portion of the RecordBatch.
-   * @param end The end of the specified portion of the RecordBatch. This is exclusive of the element at the index 'end'.
+   * @param end The end of the specified portion of the RecordBatch. This is exclusive of the row at the index 'end'.
    */
   slice(begin, end) {
     const [slice4] = new Vector([this.data]).slice(begin, end).data;
@@ -10808,8 +10863,8 @@ var AsyncMessageReader = class {
       );
     });
   }
-  readSchema(throwIfNull = false) {
-    return __awaiter(this, void 0, void 0, function* () {
+  readSchema() {
+    return __awaiter(this, arguments, void 0, function* (throwIfNull = false) {
       const type2 = MessageHeader.Schema;
       const message = yield this.readMessage(type2);
       const schema = message === null || message === void 0 ? void 0 : message.header();
@@ -11057,8 +11112,8 @@ var AsyncRecordBatchStreamReader = class extends RecordBatchReader {
     this._impl = _impl;
   }
   readAll() {
-    var _a5, e_1, _b2, _c2;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5, e_1, _b2, _c2;
       const batches = new Array();
       try {
         for (var _d2 = true, _e2 = __asyncValues(this), _f2; _f2 = yield _e2.next(), _a5 = _f2.done, !_a5; _d2 = true) {
@@ -11431,8 +11486,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   readRecordBatch(index2) {
-    var _a5;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5;
       if (this.closed) {
         return null;
       }
@@ -11453,8 +11508,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   _readDictionaryBatch(index2) {
-    var _a5;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5;
       const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getDictionaryBatch(index2);
       if (block && (yield this._handle.seek(block.offset))) {
         const message = yield this._reader.readMessage(MessageHeader.DictionaryBatch);
@@ -11959,9 +12014,9 @@ function writeAll(writer, input) {
   return writer.finish();
 }
 function writeAllAsync(writer, batches) {
-  var _a5, batches_1, batches_1_1;
-  var _b2, e_1, _c2, _d2;
   return __awaiter(this, void 0, void 0, function* () {
+    var _a5, batches_1, batches_1_1;
+    var _b2, e_1, _c2, _d2;
     try {
       for (_a5 = true, batches_1 = __asyncValues(batches); batches_1_1 = yield batches_1.next(), _b2 = batches_1_1.done, !_b2; _a5 = true) {
         _d2 = batches_1_1.value;
@@ -12324,6 +12379,13 @@ function socketConnector(uri = "ws://localhost:3000/") {
     get connected() {
       return connected;
     },
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     query(query) {
       return new Promise(
         (resolve, reject) => enqueue(query, resolve, reject)
@@ -12394,7 +12456,7 @@ function literalToSQL(value) {
     case "boolean":
       return value ? "TRUE" : "FALSE";
     case "string":
-      return `'${value}'`;
+      return `'${value.replace(`'`, `''`)}'`;
     case "number":
       return Number.isFinite(value) ? String(value) : "NULL";
     default:
@@ -12477,7 +12539,7 @@ var SQLExpression = class {
   /**
    * Annotate this expression instance with additional properties.
    * @param {object[]} [props] One or more objects with properties to add.
-   * @returns {this} This SQL expression.
+   * @returns This SQL expression.
    */
   annotate(...props) {
     return Object.assign(this, ...props);
@@ -12739,6 +12801,9 @@ var last_value = winf("LAST_VALUE");
 var nth_value = winf("NTH_VALUE");
 
 // ../sql/src/aggregates.js
+function agg(strings, ...exprs) {
+  return sql(strings, ...exprs).annotate({ aggregate: true });
+}
 var AggregateFunction = class _AggregateFunction extends SQLExpression {
   /**
    * Create a new AggregateFunction instance.
@@ -12869,6 +12934,7 @@ var entropy = aggf("ENTROPY");
 var varPop = aggf("VAR_POP");
 var stddevPop = aggf("STDDEV_POP");
 var corr = aggf("CORR");
+var covariance = aggf("COVAR_SAMP");
 var covarPop = aggf("COVAR_POP");
 var regrIntercept = aggf("REGR_INTERCEPT");
 var regrSlope = aggf("REGR_SLOPE");
@@ -12910,6 +12976,11 @@ var castDouble = (expr) => cast(expr, "DOUBLE");
 var epoch_ms = (expr) => {
   return sql`epoch_ms(${asColumn(expr)})`;
 };
+function dateBin(expr, interval2, steps = 1) {
+  const i = `INTERVAL ${steps} ${interval2}`;
+  const d = asColumn(expr);
+  return sql`TIME_BUCKET(${i}, ${d})`.annotate({ label: interval2 });
+}
 
 // ../sql/src/spatial.js
 var geojson = functionCall("ST_AsGeoJSON");
@@ -13031,7 +13102,8 @@ var Query = class _Query {
           }
         }
       }
-      query.select = query.select.concat(list);
+      const keys = new Set(list.map((x3) => x3.as));
+      query.select = query.select.filter((x3) => !keys.has(x3.as)).concat(list.filter((x3) => x3.expr));
       return this;
     }
   }
@@ -13504,6 +13576,7 @@ function scaleTime() {
   };
 }
 var scales = {
+  identity: scaleLinear,
   linear: scaleLinear,
   log: scaleLog,
   symlog: scaleSymlog,
@@ -13526,179 +13599,97 @@ function create(name, query, {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// ../core/src/util/hash.js
-function fnv_hash(v2) {
-  let a2 = 2166136261;
-  for (let i = 0, n = v2.length; i < n; ++i) {
-    const c4 = v2.charCodeAt(i);
-    const d = c4 & 65280;
-    if (d) a2 = fnv_multiply(a2 ^ d >> 8);
-    a2 = fnv_multiply(a2 ^ c4 & 255);
-  }
-  return fnv_mix(a2);
-}
-function fnv_multiply(a2) {
-  return a2 + (a2 << 1) + (a2 << 4) + (a2 << 7) + (a2 << 8) + (a2 << 24);
-}
-function fnv_mix(a2) {
-  a2 += a2 << 13;
-  a2 ^= a2 >>> 7;
-  a2 += a2 << 3;
-  a2 ^= a2 >>> 17;
-  a2 += a2 << 5;
-  return a2 & 4294967295;
-}
-
-// ../core/src/DataCubeIndexer.js
-var DataCubeIndexer = class {
-  /**
-   *
-   * @param {import('./Coordinator.js').Coordinator} mc a Mosaic coordinator
-   * @param {*} options Options hash to configure the data cube indexes and pass selections to the coordinator.
-   */
-  constructor(mc, { selection: selection2, temp = true }) {
-    this.mc = mc;
-    this.selection = selection2;
-    this.temp = temp;
-    this.reset();
-  }
-  reset() {
-    this.enabled = false;
-    this.clients = null;
-    this.indices = null;
-    this.activeView = null;
-  }
-  clear() {
-    if (this.indices) {
-      this.mc.cancel(Array.from(this.indices.values(), (index2) => index2.result));
-      this.indices = null;
-    }
-  }
-  index(clients, active) {
-    if (this.clients !== clients) {
-      const cols = Array.from(clients, getIndexColumns);
-      const from = cols[0]?.from;
-      this.enabled = cols.every((c4) => c4 && c4.from === from);
-      this.clients = clients;
-      this.activeView = null;
-      this.clear();
-    }
-    if (!this.enabled) return false;
-    active = active || this.selection.active;
-    const { source } = active;
-    if (source && source === this.activeView?.source) return true;
-    this.clear();
-    if (!source) return false;
-    const activeView = this.activeView = getActiveView(active);
-    if (!activeView) return false;
-    this.mc.logger().warn("DATA CUBE INDEX CONSTRUCTION");
-    const sel = this.selection.remove(source);
-    const indices = this.indices = /* @__PURE__ */ new Map();
-    const { mc, temp } = this;
-    for (const client of clients) {
-      if (sel.skip(client, active)) continue;
-      const index2 = getIndexColumns(client);
-      const query = client.query(sel.predicate(client)).select({ ...activeView.columns, ...index2.aux }).groupby(Object.keys(activeView.columns));
-      const [subq] = query.subqueries;
-      if (subq) {
-        const cols = Object.values(activeView.columns).map((c4) => c4.columns[0]);
-        subqueryPushdown(subq, cols);
-      }
-      const order = query.orderby();
-      query.query.orderby = [];
-      const sql2 = query.toString();
-      const id2 = (fnv_hash(sql2) >>> 0).toString(16);
-      const table = `cube_index_${id2}`;
-      const result = mc.exec(create(table, sql2, { temp }));
-      indices.set(client, { table, result, order, ...index2 });
-    }
-    return true;
-  }
-  async update() {
-    const { clients, selection: selection2, activeView } = this;
-    const filter3 = activeView.predicate(selection2.active.predicate);
-    return Promise.all(
-      Array.from(clients).map((client) => this.updateClient(client, filter3))
-    );
-  }
-  async updateClient(client, filter3) {
-    const index2 = this.indices.get(client);
-    if (!index2) return;
-    if (!filter3) {
-      filter3 = this.activeView.predicate(this.selection.active.predicate);
-    }
-    const { table, dims, aggr, order = [] } = index2;
-    const query = Query.select(dims, aggr).from(table).groupby(dims).where(filter3).orderby(order);
-    return this.mc.updateClient(client, query);
-  }
-};
-function getActiveView(clause) {
-  const { source, schema } = clause;
-  let columns = clause.predicate?.columns;
-  if (!schema || !columns) return null;
-  const { type: type2, scales: scales2, pixelSize = 1 } = schema;
-  let predicate;
-  if (type2 === "interval" && scales2) {
-    const bins2 = scales2.map((s2) => binInterval(s2, pixelSize));
-    if (bins2.some((b) => b == null)) return null;
-    if (bins2.length === 1) {
-      predicate = (p) => p ? isBetween("active0", p.range.map(bins2[0])) : [];
-      columns = { active0: bins2[0](clause.predicate.field) };
-    } else {
-      predicate = (p) => p ? and(p.children.map(({ range: range3 }, i) => isBetween(`active${i}`, range3.map(bins2[i])))) : [];
-      columns = Object.fromEntries(
-        clause.predicate.children.map((p, i) => [`active${i}`, bins2[i](p.field)])
-      );
-    }
-  } else if (type2 === "point") {
-    predicate = (x3) => x3;
-    columns = Object.fromEntries(columns.map((col) => [col.toString(), col]));
-  } else {
-    return null;
-  }
-  return { source, columns, predicate };
-}
-function binInterval(scale3, pixelSize) {
-  const { apply: apply2, sqlApply } = scaleTransform(scale3);
-  if (apply2) {
-    const { domain, range: range3 } = scale3;
-    const lo = apply2(Math.min(...domain));
-    const hi = apply2(Math.max(...domain));
-    const a2 = Math.abs(range3[1] - range3[0]) / (hi - lo) / pixelSize;
-    const s2 = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-    return (value) => sql`${s2}FLOOR(${a2}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
-  }
-}
-var NO_INDEX = { from: NaN };
-function getIndexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
+// ../core/src/util/index-columns.js
+function indexColumns(client) {
+  if (!client.filterIndexable) return null;
   const q = client.query();
   const from = getBaseTable(q);
-  if (!from || !q.groupby) return NO_INDEX;
-  const g = new Set(q.groupby().map((c4) => c4.column));
+  if (typeof from !== "string" || !q.select) return null;
   const aggr = [];
   const dims = [];
   const aux = {};
-  let auxAs;
   for (const entry of q.select()) {
     const { as, expr: { aggregate, args } } = entry;
     const op = aggregate?.toUpperCase?.();
     switch (op) {
       case "COUNT":
       case "SUM":
-        aggr.push({ [as]: sql`SUM("${as}")::DOUBLE` });
+        aggr.push({ [as]: agg`SUM("${as}")::DOUBLE` });
         break;
       case "AVG":
-        aux[auxAs = "__count__"] = sql`COUNT(*)`;
-        aggr.push({ [as]: sql`(SUM("${as}" * ${auxAs}) / SUM(${auxAs}))::DOUBLE` });
+        aggr.push({ [as]: avgExpr(aux, as, args[0]) });
         break;
       case "ARG_MAX":
-        aux[auxAs = `__max_${as}__`] = sql`MAX(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MAX("${as}", ${auxAs})` });
+        aggr.push({ [as]: argmaxExpr(aux, as, args) });
         break;
       case "ARG_MIN":
-        aux[auxAs = `__min_${as}__`] = sql`MIN(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MIN("${as}", ${auxAs})` });
+        aggr.push({ [as]: argminExpr(aux, as, args) });
+        break;
+      case "VARIANCE":
+      case "VAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from) });
+        break;
+      case "VAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from, false) });
+        break;
+      case "STDDEV":
+      case "STDDEV_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from)})` });
+        break;
+      case "STDDEV_POP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from, false)})` });
+        break;
+      case "COVAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from) });
+        break;
+      case "COVAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, false) });
+        break;
+      case "CORR":
+        aux[as] = null;
+        aggr.push({ [as]: corrExpr(aux, args, from) });
+        break;
+      case "REGR_COUNT":
+        aux[as] = null;
+        aggr.push({ [as]: agg`${regrCountExpr(aux, args)}::DOUBLE` });
+        break;
+      case "REGR_AVGX":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgXExpr(aux, args) });
+        break;
+      case "REGR_AVGY":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgYExpr(aux, args) });
+        break;
+      case "REGR_SYY":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 0, args, from) });
+        break;
+      case "REGR_SXX":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 1, args, from) });
+        break;
+      case "REGR_SXY":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, null) });
+        break;
+      case "REGR_SLOPE":
+        aux[as] = null;
+        aggr.push({ [as]: regrSlopeExpr(aux, args, from) });
+        break;
+      case "REGR_INTERCEPT":
+        aux[as] = null;
+        aggr.push({ [as]: regrInterceptExpr(aux, args, from) });
+        break;
+      case "REGR_R2":
+        aux[as] = null;
+        aggr.push({ [as]: agg`(${corrExpr(aux, args, from)}) ** 2` });
         break;
       case "MAX":
       case "MIN":
@@ -13708,14 +13699,22 @@ function getIndexColumns(client) {
       case "BOOL_AND":
       case "BOOL_OR":
       case "PRODUCT":
-        aggr.push({ [as]: sql`${op}("${as}")` });
+        aggr.push({ [as]: agg`${op}("${as}")` });
         break;
       default:
-        if (g.has(as)) dims.push(as);
+        if (!aggregate) dims.push(as);
         else return null;
     }
   }
-  return { aggr, dims, aux, from };
+  if (!aggr.length) return null;
+  return { from, dims, aggr, aux };
+}
+function auxName(type2, ...args) {
+  const cols = args.length ? "_" + args.map(sanitize).join("_") : "";
+  return `__${type2}${cols}__`;
+}
+function sanitize(col) {
+  return `${col}`.replaceAll('"', "").replaceAll(" ", "_");
 }
 function getBaseTable(query) {
   const subq = query.subqueries;
@@ -13732,6 +13731,291 @@ function getBaseTable(query) {
   }
   return base;
 }
+function countExpr(aux, arg) {
+  const n = auxName("count", arg);
+  aux[n] = agg`COUNT(${arg})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function avgExpr(aux, as, arg) {
+  const n = countExpr(aux, arg);
+  return agg`(SUM("${as}" * ${n.name}) / ${n})`;
+}
+function avg2(x3, from) {
+  return sql`(SELECT AVG(${x3}) FROM "${from}")`;
+}
+function argmaxExpr(aux, as, [, y3]) {
+  const max4 = auxName("max", y3);
+  aux[max4] = agg`MAX(${y3})`;
+  return agg`ARG_MAX("${as}", ${max4})`;
+}
+function argminExpr(aux, as, [, y3]) {
+  const min5 = auxName("min", y3);
+  aux[min5] = agg`MIN(${y3})`;
+  return agg`ARG_MIN("${as}", ${min5})`;
+}
+function varianceExpr(aux, x3, from, correction = true) {
+  const n = countExpr(aux, x3);
+  const ssq = auxName("rssq", x3);
+  const sum4 = auxName("rsum", x3);
+  const delta = sql`${x3} - ${avg2(x3, from)}`;
+  aux[ssq] = agg`SUM((${delta}) ** 2)`;
+  aux[sum4] = agg`SUM(${delta})`;
+  const adj = correction ? ` - 1` : "";
+  return agg`(SUM(${ssq}) - (SUM(${sum4}) ** 2 / ${n})) / (${n}${adj})`;
+}
+function covarianceExpr(aux, args, from, correction = true) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const adj = correction === null ? "" : correction ? ` / (${n} - 1)` : ` / ${n}`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n})${adj}`;
+}
+function corrExpr(aux, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sxx = regrSumSqExpr(aux, 1, args, from);
+  const syy = regrSumSqExpr(aux, 0, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const vx = agg`(${sxx} - (${sx} ** 2) / ${n})`;
+  const vy = agg`(${syy} - (${sy} ** 2) / ${n})`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n}) / SQRT(${vx} * ${vy})`;
+}
+function regrCountExpr(aux, [y3, x3]) {
+  const n = auxName("count", y3, x3);
+  aux[n] = agg`REGR_COUNT(${y3}, ${x3})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function regrSumExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const o = args[1 - i];
+  const sum4 = auxName("rs", v2);
+  aux[sum4] = agg`SUM(${v2} - ${avg2(v2, from)}) FILTER (${o} IS NOT NULL)`;
+  return agg`SUM(${sum4})`;
+}
+function regrSumSqExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const u4 = args[1 - i];
+  const ssq = auxName("rss", v2);
+  aux[ssq] = agg`SUM((${v2} - ${avg2(v2, from)}) ** 2) FILTER (${u4} IS NOT NULL)`;
+  return agg`SUM(${ssq})`;
+}
+function regrSumXYExpr(aux, args, from) {
+  const [y3, x3] = args;
+  const sxy = auxName("sxy", y3, x3);
+  aux[sxy] = agg`SUM((${x3} - ${avg2(x3, from)}) * (${y3} - ${avg2(y3, from)}))`;
+  return agg`SUM(${sxy})`;
+}
+function regrAvgXExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", x3, y3);
+  aux[a2] = agg`REGR_AVGX(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrAvgYExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", y3, x3);
+  aux[a2] = agg`REGR_AVGY(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrVarExpr(aux, i, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sum4 = regrSumExpr(aux, i, args, from);
+  const ssq = regrSumSqExpr(aux, i, args, from);
+  return agg`(${ssq} - (${sum4} ** 2 / ${n}))`;
+}
+function regrSlopeExpr(aux, args, from) {
+  const cov = covarianceExpr(aux, args, from, null);
+  const varx = regrVarExpr(aux, 1, args, from);
+  return agg`(${cov}) / ${varx}`;
+}
+function regrInterceptExpr(aux, args, from) {
+  const ax = regrAvgXExpr(aux, args);
+  const ay = regrAvgYExpr(aux, args);
+  const m = regrSlopeExpr(aux, args, from);
+  return agg`${ay} - (${m}) * ${ax}`;
+}
+
+// ../core/src/util/hash.js
+function fnv_hash(v2) {
+  let a2 = 2166136261;
+  for (let i = 0, n = v2.length; i < n; ++i) {
+    const c4 = v2.charCodeAt(i);
+    const d = c4 & 65280;
+    if (d) a2 = fnv_multiply(a2 ^ d >> 8);
+    a2 = fnv_multiply(a2 ^ c4 & 255);
+  }
+  return fnv_mix(a2);
+}
+function fnv_multiply(a2) {
+  return a2 + (a2 << 1) + (a2 << 4) + (a2 << 7) + (a2 << 8) + (a2 << 24);
+}
+function fnv_mix(a2) {
+  a2 += a2 << 13;
+  a2 ^= a2 >>> 7;
+  a2 += a2 << 3;
+  a2 ^= a2 >>> 17;
+  a2 += a2 << 5;
+  return a2 & 4294967295;
+}
+
+// ../core/src/DataCubeIndexer.js
+var Skip = { skip: true, result: null };
+var DataCubeIndexer = class {
+  /**
+   * Create a new data cube index table manager.
+   * @param {import('./Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
+   * @param {object} [options] Indexer options.
+   * @param {boolean} [options.enabled=true] Flag to enable/disable indexer.
+   * @param {boolean} [options.temp=true] Flag to indicate if generated data
+   *  cube index tables should be temporary tables.
+   */
+  constructor(coordinator2, {
+    enabled = true,
+    temp = true
+  } = {}) {
+    this.indexes = /* @__PURE__ */ new Map();
+    this.active = null;
+    this.temp = temp;
+    this.mc = coordinator2;
+    this._enabled = enabled;
+  }
+  /**
+   * Set the enabled state of this indexer. If false, any cached state is
+   * cleared and subsequent index calls will return null until re-enabled.
+   * @param {boolean} state The enabled state.
+   */
+  enabled(state) {
+    if (state === void 0) {
+      return this._enabled;
+    } else if (this._enabled !== state) {
+      if (!state) this.clear();
+      this._enabled = state;
+    }
+  }
+  /**
+   * Clear the cache of data cube index table entries for the current active
+   * selection clause. This method will also cancel any queued data cube table
+   * creation queries that have not yet been submitted to the database. This
+   * method does _not_ drop any existing data cube tables.
+   */
+  clear() {
+    this.mc.cancel(Array.from(this.indexes.values(), (info) => info?.result));
+    this.indexes.clear();
+    this.active = null;
+  }
+  /**
+   * Return data cube index table information for the active state of a
+   * client-selection pair, or null if the client is not indexable. This
+   * method has multiple possible side effects, including data cube table
+   * generation and updating internal caches.
+   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
+   * @param {import('./Selection.js').Selection} selection A Mosaic selection
+   *  to filter the client by.
+   * @param {import('./util/selection-types.js').SelectionClause} activeClause
+   *  A representative active selection clause for which to (possibly) generate
+   *  data cube index tables.
+   * @returns {DataCubeInfo | Skip | null} Data cube index table
+   *  information and query generator, or null if the client is not indexable.
+   */
+  index(client, selection2, activeClause) {
+    if (!this._enabled) return null;
+    const { indexes: indexes2, mc, temp } = this;
+    const { source } = activeClause;
+    if (!source) return null;
+    if (this.active) {
+      if (this.active.source !== source) this.clear();
+      if (this.active?.source === null) return null;
+    }
+    let { active } = this;
+    if (!active) {
+      this.active = active = activeColumns(activeClause);
+      if (active.source === null) return null;
+    }
+    if (indexes2.has(client)) {
+      return indexes2.get(client);
+    }
+    const indexCols = indexColumns(client);
+    let info;
+    if (!indexCols) {
+      info = null;
+    } else if (selection2.skip(client, activeClause)) {
+      info = Skip;
+    } else {
+      const filter3 = selection2.remove(source).predicate(client);
+      info = dataCubeInfo(client.query(filter3), active, indexCols);
+      info.result = mc.exec(create(info.table, info.create, { temp }));
+      info.result.catch((e) => mc.logger().error(e));
+    }
+    indexes2.set(client, info);
+    return info;
+  }
+};
+function activeColumns(clause) {
+  const { source, meta } = clause;
+  const clausePred = clause.predicate;
+  const clauseCols = clausePred?.columns;
+  let predicate;
+  let columns;
+  if (!meta || !clauseCols) {
+    return { source: null, columns, predicate };
+  }
+  const { type: type2, scales: scales2, bin: bin3, pixelSize = 1 } = meta;
+  if (type2 === "point") {
+    predicate = (x3) => x3;
+    columns = Object.fromEntries(
+      clauseCols.map((col) => [`${col}`, asColumn(col)])
+    );
+  } else if (type2 === "interval" && scales2) {
+    const bins2 = scales2.map((s2) => binInterval(s2, pixelSize, bin3));
+    if (bins2.some((b) => !b)) {
+    } else if (bins2.length === 1) {
+      predicate = (p) => p ? isBetween("active0", p.range.map(bins2[0])) : [];
+      columns = { active0: bins2[0](clausePred.field) };
+    } else {
+      predicate = (p) => p ? and(p.children.map(
+        ({ range: range3 }, i) => isBetween(`active${i}`, range3.map(bins2[i]))
+      )) : [];
+      columns = Object.fromEntries(
+        // @ts-ignore
+        clausePred.children.map((p, i) => [`active${i}`, bins2[i](p.field)])
+      );
+    }
+  }
+  return { source: columns ? source : null, columns, predicate };
+}
+var BIN = { ceil: "CEIL", round: "ROUND" };
+function binInterval(scale3, pixelSize, bin3) {
+  const { type: type2, domain, range: range3, apply: apply2, sqlApply } = scaleTransform(scale3);
+  if (!apply2) return;
+  const fn = BIN[`${bin3}`.toLowerCase()] || "FLOOR";
+  const lo = apply2(Math.min(...domain));
+  const hi = apply2(Math.max(...domain));
+  const a2 = type2 === "identity" ? 1 : Math.abs(range3[1] - range3[0]) / (hi - lo);
+  const s2 = a2 / pixelSize === 1 ? "" : `${a2 / pixelSize}::DOUBLE * `;
+  const d = lo === 0 ? "" : ` - ${lo}::DOUBLE`;
+  return (value) => sql`${fn}(${s2}(${sqlApply(value)}${d}))::INTEGER`;
+}
+function dataCubeInfo(clientQuery, active, indexCols) {
+  const { dims, aggr, aux } = indexCols;
+  const { columns } = active;
+  const query = clientQuery.select({ ...columns, ...aux }).groupby(Object.keys(columns));
+  const [subq] = query.subqueries;
+  if (subq) {
+    const cols = Object.values(columns).flatMap((c4) => c4.columns);
+    subqueryPushdown(subq, cols);
+  }
+  const order = query.orderby();
+  query.query.orderby = [];
+  const create4 = query.toString();
+  const id2 = (fnv_hash(create4) >>> 0).toString(16);
+  const table = `cube_index_${id2}`;
+  const select2 = Query.select(dims, aggr).from(table).groupby(dims).orderby(order);
+  return new DataCubeInfo({ table, create: create4, active, select: select2 });
+}
 function subqueryPushdown(query, cols) {
   const memo2 = /* @__PURE__ */ new Set();
   const pushdown = (q) => {
@@ -13744,78 +14028,65 @@ function subqueryPushdown(query, cols) {
   };
   pushdown(query);
 }
-
-// ../core/src/FilterGroup.js
-var FilterGroup = class {
+var DataCubeInfo = class {
   /**
-   * @param {import('./Coordinator.js').Coordinator} coordinator The Mosaic coordinator.
-   * @param {*} selection The shared filter selection.
-   * @param {*} index Boolean flag or options hash for data cube indexer.
-   *  Falsy values disable indexing.
+   * Create a new DataCubeInfo instance.
+   * @param {object} options
    */
-  constructor(coordinator2, selection2, index2 = true) {
-    this.mc = coordinator2;
-    this.selection = selection2;
-    this.clients = /* @__PURE__ */ new Set();
-    this.indexer = index2 ? new DataCubeIndexer(this.mc, { ...index2, selection: selection2 }) : null;
-    const { value, activate } = this.handlers = {
-      value: () => this.update(),
-      activate: (clause) => this.indexer?.index(this.clients, clause)
-    };
-    selection2.addEventListener("value", value);
-    selection2.addEventListener("activate", activate);
-  }
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener("value", value);
-    this.selection.removeEventListener("activate", activate);
-  }
-  reset() {
-    this.indexer?.reset();
+  constructor({ table, create: create4, active, select: select2 } = {}) {
+    this.table = table;
+    this.create = create4;
+    this.result = null;
+    this.active = active;
+    this.select = select2;
+    this.skip = false;
+  }
+  /**
+   * Generate a data cube index table query for the given predicate.
+   * @param {import('@uwdata/mosaic-sql').SQLExpression} predicate The current
+   *  active clause predicate.
+   * @returns {Query} A data cube index table query.
+   */
+  query(predicate) {
+    return this.select.clone().where(this.active.predicate(predicate));
   }
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
+};
+
+// ../core/src/util/query-result.js
+var QueryResult = class extends Promise {
+  /**
+   * Create a new query result Promise.
+   */
+  constructor() {
+    let resolve;
+    let reject;
+    super((r, e) => {
+      resolve = r;
+      reject = e;
+    });
+    this._resolve = resolve;
+    this._reject = reject;
   }
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
-    }
+  /**
+   * Resolve the result Promise with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
+   */
+  fulfill(value) {
+    this._resolve(value);
     return this;
   }
   /**
-   * Internal method to process a selection update.
-   * The return value is passed as a selection callback value.
-   * @returns {Promise} A Promise that resolves when the update completes.
+   * Rejects the result Promise with the provided error.
+   * @param {*} error The error value.
+   * @returns {this}
    */
-  update() {
-    const { mc, indexer, clients, selection: selection2 } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection2);
+  reject(error) {
+    this._reject(error);
+    return this;
   }
 };
-function defaultUpdate(mc, clients, selection2) {
-  return Promise.all(Array.from(clients).map((client) => {
-    const filter3 = selection2.predicate(client);
-    if (filter3 != null) {
-      return mc.updateClient(client, client.query(filter3));
-    }
-  }));
-}
-
-// ../core/src/util/query-result.js
-function queryResult() {
-  let resolve;
-  let reject;
-  const p = new Promise((r, e) => {
-    resolve = r;
-    reject = e;
-  });
-  return Object.assign(p, {
-    fulfill: (value) => (resolve(value), p),
-    reject: (err) => (reject(err), p)
-  });
-}
+QueryResult.prototype.constructor = Promise;
 
 // ../core/src/QueryConsolidator.js
 function wait(callback) {
@@ -13891,7 +14162,7 @@ function consolidate(group3, enqueue, record) {
         record: false,
         query: group3.query = consolidatedQuery(group3, record)
       },
-      result: group3.result = queryResult()
+      result: group3.result = new QueryResult()
     });
   } else {
     for (const { entry, priority } of group3) {
@@ -14107,115 +14378,124 @@ function priorityQueue(ranks) {
 
 // ../core/src/QueryManager.js
 var Priority = { High: 0, Normal: 1, Low: 2 };
-function QueryManager() {
-  const queue = priorityQueue(3);
-  let db;
-  let clientCache;
-  let logger;
-  let recorders = [];
-  let pending = null;
-  let consolidate2;
-  function next() {
-    if (pending || queue.isEmpty()) return;
-    const { request, result } = queue.next();
-    pending = submit(request, result);
-    pending.finally(() => {
-      pending = null;
-      next();
+var QueryManager = class {
+  constructor() {
+    this.queue = priorityQueue(3);
+    this.db = null;
+    this.clientCache = null;
+    this._logger = null;
+    this._logQueries = false;
+    this.recorders = [];
+    this.pending = null;
+    this._consolidate = null;
+  }
+  next() {
+    if (this.pending || this.queue.isEmpty()) return;
+    const { request, result } = this.queue.next();
+    this.pending = this.submit(request, result);
+    this.pending.finally(() => {
+      this.pending = null;
+      this.next();
     });
   }
-  function enqueue(entry, priority = Priority.Normal) {
-    queue.insert(entry, priority);
-    next();
+  enqueue(entry, priority = Priority.Normal) {
+    this.queue.insert(entry, priority);
+    this.next();
   }
-  function recordQuery(sql2) {
-    if (recorders.length && sql2) {
-      recorders.forEach((rec) => rec.add(sql2));
+  recordQuery(sql2) {
+    if (this.recorders.length && sql2) {
+      this.recorders.forEach((rec) => rec.add(sql2));
     }
   }
-  async function submit(request, result) {
+  async submit(request, result) {
     try {
       const { query, type: type2, cache = false, record = true, options } = request;
       const sql2 = query ? `${query}` : null;
       if (record) {
-        recordQuery(sql2);
+        this.recordQuery(sql2);
       }
       if (cache) {
-        const cached = clientCache.get(sql2);
+        const cached = this.clientCache.get(sql2);
         if (cached) {
-          logger.debug("Cache");
+          this._logger.debug("Cache");
           result.fulfill(cached);
           return;
         }
       }
       const t03 = performance.now();
-      const data = await db.query({ type: type2, sql: sql2, ...options });
-      if (cache) clientCache.set(sql2, data);
-      logger.debug(`Request: ${(performance.now() - t03).toFixed(1)}`);
+      if (this._logQueries) {
+        this._logger.debug("Query", { type: type2, sql: sql2, ...options });
+      }
+      const data = await this.db.query({ type: type2, sql: sql2, ...options });
+      if (cache) this.clientCache.set(sql2, data);
+      this._logger.debug(`Request: ${(performance.now() - t03).toFixed(1)}`);
       result.fulfill(data);
     } catch (err) {
       result.reject(err);
     }
   }
-  return {
-    cache(value) {
-      return value !== void 0 ? clientCache = value === true ? lruCache() : value || voidCache() : clientCache;
-    },
-    logger(value) {
-      return value ? logger = value : logger;
-    },
-    connector(connector) {
-      return connector ? db = connector : db;
-    },
-    consolidate(flag) {
-      if (flag && !consolidate2) {
-        consolidate2 = consolidator(enqueue, clientCache, recordQuery);
-      } else if (!flag && consolidate2) {
-        consolidate2 = null;
-      }
-    },
-    request(request, priority = Priority.Normal) {
-      const result = queryResult();
-      const entry = { request, result };
-      if (consolidate2) {
-        consolidate2.add(entry, priority);
-      } else {
-        enqueue(entry, priority);
-      }
-      return result;
-    },
-    cancel(requests) {
-      const set3 = new Set(requests);
-      queue.remove(({ result }) => set3.has(result));
-    },
-    clear() {
-      queue.remove(({ result }) => {
-        result.reject("Cleared");
-        return true;
-      });
-    },
-    record() {
-      let state = [];
-      const recorder = {
-        add(query) {
-          state.push(query);
-        },
-        reset() {
-          state = [];
-        },
-        snapshot() {
-          return state.slice();
-        },
-        stop() {
-          recorders = recorders.filter((x3) => x3 !== recorder);
-          return state;
-        }
-      };
-      recorders.push(recorder);
-      return recorder;
+  cache(value) {
+    return value !== void 0 ? this.clientCache = value === true ? lruCache() : value || voidCache() : this.clientCache;
+  }
+  logger(value) {
+    return value ? this._logger = value : this._logger;
+  }
+  logQueries(value) {
+    return value !== void 0 ? this._logQueries = !!value : this._logQueries;
+  }
+  connector(connector) {
+    return connector ? this.db = connector : this.db;
+  }
+  consolidate(flag) {
+    if (flag && !this._consolidate) {
+      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache, this.recordQuery.bind(this));
+    } else if (!flag && this._consolidate) {
+      this._consolidate = null;
     }
-  };
-}
+  }
+  request(request, priority = Priority.Normal) {
+    const result = new QueryResult();
+    const entry = { request, result };
+    if (this._consolidate) {
+      this._consolidate.add(entry, priority);
+    } else {
+      this.enqueue(entry, priority);
+    }
+    return result;
+  }
+  cancel(requests) {
+    const set3 = new Set(requests);
+    if (set3.size) {
+      this.queue.remove(({ result }) => set3.has(result));
+    }
+  }
+  clear() {
+    this.queue.remove(({ result }) => {
+      result.reject("Cleared");
+      return true;
+    });
+  }
+  record() {
+    let state = [];
+    const recorder = {
+      add(query) {
+        state.push(query);
+      },
+      reset() {
+        state = [];
+      },
+      snapshot() {
+        return state.slice();
+      },
+      stop() {
+        this.recorders = this.recorders.filter((x3) => x3 !== recorder);
+        return state;
+      }
+    };
+    this.recorders.push(recorder);
+    return recorder;
+  }
+};
 
 // ../core/src/util/js-type.js
 function jsType(type2) {
@@ -14296,23 +14576,26 @@ function convertArrowColumn(column3) {
   }
   if (DataType.isInt(type2) && type2.bitWidth >= 64) {
     const size = column3.length;
-    const array4 = new Float64Array(size);
+    const array4 = column3.nullCount ? new Array(size) : new Float64Array(size);
     for (let row = 0; row < size; ++row) {
       const v2 = column3.get(row);
-      array4[row] = v2 == null ? NaN : Number(v2);
+      array4[row] = v2 == null ? null : Number(v2);
     }
     return array4;
   }
   if (DataType.isDecimal(type2)) {
     const scale3 = 1 / Math.pow(10, type2.scale);
     const size = column3.length;
-    const array4 = new Float64Array(size);
+    const array4 = column3.nullCount ? new Array(size) : new Float64Array(size);
     for (let row = 0; row < size; ++row) {
       const v2 = column3.get(row);
-      array4[row] = v2 == null ? NaN : decimalToNumber(v2, scale3);
+      array4[row] = v2 == null ? null : decimalToNumber(v2, scale3);
     }
     return array4;
   }
+  if (column3.nullCount) {
+    return Array.from(column3);
+  }
   return column3.toArray();
 }
 var BASE32 = Array.from(
@@ -14419,58 +14702,92 @@ function coordinator(instance8) {
   return _instance;
 }
 var Coordinator = class {
-  constructor(db = socketConnector(), options = {}) {
-    const {
-      logger = console,
-      manager = QueryManager()
-    } = options;
+  constructor(db = socketConnector(), {
+    logger = console,
+    manager = new QueryManager(),
+    cache = true,
+    consolidate: consolidate2 = true,
+    indexes: indexes2 = {}
+  } = {}) {
     this.manager = manager;
+    this.manager.cache(cache);
+    this.manager.consolidate(consolidate2);
+    this.dataCubeIndexer = new DataCubeIndexer(this, indexes2);
     this.logger(logger);
-    this.configure(options);
     this.databaseConnector(db);
     this.clear();
   }
-  logger(logger) {
-    if (arguments.length) {
-      this._logger = logger || voidLogger();
-      this.manager.logger(this._logger);
-    }
-    return this._logger;
-  }
   /**
-   * Set configuration options for this coordinator.
-   * @param {object} [options] Configration options.
-   * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
-   * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
-   * @param {boolean|object} [options.indexes=true] Boolean flag to enable/disable
-   *  automatic data cube indexes or an index options object.
+   * Clear the coordinator state.
+   * @param {object} [options] Options object.
+   * @param {boolean} [options.clients=true] If true, disconnect all clients.
+   * @param {boolean} [options.cache=true] If true, clear the query cache.
    */
-  configure({ cache = true, consolidate: consolidate2 = true, indexes: indexes2 = true } = {}) {
-    this.manager.cache(cache);
-    this.manager.consolidate(consolidate2);
-    this.indexes = indexes2;
-  }
   clear({ clients = true, cache = true } = {}) {
     this.manager.clear();
     if (clients) {
+      this.filterGroups?.forEach((group3) => group3.disconnect());
+      this.filterGroups = /* @__PURE__ */ new Map();
       this.clients?.forEach((client) => this.disconnect(client));
-      this.filterGroups?.forEach((group3) => group3.finalize());
       this.clients = /* @__PURE__ */ new Set();
-      this.filterGroups = /* @__PURE__ */ new Map();
     }
     if (cache) this.manager.cache().clear();
   }
+  /**
+   * Get or set the database connector.
+   * @param {*} [db] The database connector to use.
+   * @returns The current database connector.
+   */
   databaseConnector(db) {
     return this.manager.connector(db);
   }
+  /**
+   * Get or set the logger.
+   * @param {*} logger  The logger to use.
+   * @returns The current logger
+   */
+  logger(logger) {
+    if (arguments.length) {
+      this._logger = logger || voidLogger();
+      this.manager.logger(this._logger);
+    }
+    return this._logger;
+  }
   // -- Query Management ----
+  /**
+   * Cancel previosuly submitted query requests. These queries will be
+   * canceled if they are queued but have not yet been submitted.
+   * @param {import('./util/query-result.js').QueryResult[]} requests An array
+   *  of query result objects, such as those returned by the `query` method.
+   */
   cancel(requests) {
     this.manager.cancel(requests);
   }
+  /**
+   * Issue a query for which no result (return value) is needed.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {number} [options.priority] The query priority, defaults to
+   *  `Priority.Normal`.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   exec(query, { priority = Priority.Normal } = {}) {
     query = Array.isArray(query) ? query.join(";\n") : query;
     return this.manager.request({ type: "exec", query }, priority);
   }
+  /**
+   * Issue a query to the backing database. The submitted query may be
+   * consolidate with other queries and its results may be cached.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {'arrow' | 'json'} [options.type] The query result format type.
+   * @param {boolean} [options.cache=true] If true, cache the query result.
+   * @param {number} [options.priority] The query priority, defaults to
+   *  `Priority.Normal`.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   query(query, {
     type: type2 = "arrow",
     cache = true,
@@ -14479,6 +14796,15 @@ var Coordinator = class {
   } = {}) {
     return this.manager.request({ type: type2, query, cache, options }, priority);
   }
+  /**
+   * Issue a query to prefetch data for later use. The query result is cached
+   * for efficient future access.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {'arrow' | 'json'} [options.type] The query result format type.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   prefetch(query, options = {}) {
     return this.query(query, { ...options, cache: true, priority: Priority.Low });
   }
@@ -14491,26 +14817,44 @@ var Coordinator = class {
     return this.manager.request({ type: "load-bundle", options }, priority);
   }
   // -- Client Management ----
+  /**
+   * Update client data by submitting the given query and returning the
+   * data (or error) to the client.
+   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The data query.
+   * @param {number} [priority] The query priority.
+   * @returns {Promise} A Promise that resolves upon completion of the update.
+   */
   updateClient(client, query, priority = Priority.Normal) {
     client.queryPending();
     return this.query(query, { priority }).then(
       (data) => client.queryResult(data).update(),
       (err) => {
-        client.queryError(err);
         this._logger.error(err);
+        client.queryError(err);
       }
-    );
+    ).catch((err) => this._logger.error(err));
   }
+  /**
+   * Issue a query request for a client. If the query is null or undefined,
+   * the client is simply updated. Otherwise `updateClient` is called. As a
+   * side effect, this method clears the current data cube indexer state.
+   * @param {import('./MosaicClient.js').MosaicClient} client The client
+   *  to update.
+   * @param {import('@uwdata/mosaic-sql').Query | string | null} [query]
+   *  The query to issue.
+   */
   requestQuery(client, query) {
-    this.filterGroups.get(client.filterBy)?.reset();
+    this.dataCubeIndexer.clear();
     return query ? this.updateClient(client, query) : client.update();
   }
   /**
    * Connect a client to the coordinator.
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
+   *  client to connect.
    */
   async connect(client) {
-    const { clients, filterGroups, indexes: indexes2 } = this;
+    const { clients } = this;
     if (clients.has(client)) {
       throw new Error("Client already connected.");
     }
@@ -14520,30 +14864,64 @@ var Coordinator = class {
     if (fields?.length) {
       client.fieldInfo(await queryFieldInfo(this, fields));
     }
-    const filter3 = client.filterBy;
-    if (filter3) {
-      if (filterGroups.has(filter3)) {
-        filterGroups.get(filter3).add(client);
-      } else {
-        const group3 = new FilterGroup(this, filter3, indexes2);
-        filterGroups.set(filter3, group3.add(client));
-      }
-    }
+    connectSelection(this, client.filterBy, client);
     client.requestQuery();
   }
   /**
    * Disconnect a client from the coordinator.
-   *
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
+   *  client to disconnect.
    */
   disconnect(client) {
     const { clients, filterGroups } = this;
     if (!clients.has(client)) return;
     clients.delete(client);
-    filterGroups.get(client.filterBy)?.remove(client);
     client.coordinator = null;
+    const group3 = filterGroups.get(client.filterBy);
+    if (group3) {
+      group3.clients.delete(client);
+    }
   }
 };
+function connectSelection(mc, selection2, client) {
+  if (!selection2) return;
+  let entry = mc.filterGroups.get(selection2);
+  if (!entry) {
+    const activate = (clause) => activateSelection(mc, selection2, clause);
+    const value = () => updateSelection(mc, selection2);
+    selection2.addEventListener("activate", activate);
+    selection2.addEventListener("value", value);
+    entry = {
+      selection: selection2,
+      clients: /* @__PURE__ */ new Set(),
+      disconnect() {
+        selection2.removeEventListener("activate", activate);
+        selection2.removeEventListener("value", value);
+      }
+    };
+    mc.filterGroups.set(selection2, entry);
+  }
+  entry.clients.add(client);
+}
+function activateSelection(mc, selection2, clause) {
+  const { dataCubeIndexer, filterGroups } = mc;
+  const { clients } = filterGroups.get(selection2);
+  for (const client of clients) {
+    dataCubeIndexer.index(client, selection2, clause);
+  }
+}
+function updateSelection(mc, selection2) {
+  const { dataCubeIndexer, filterGroups } = mc;
+  const { clients } = filterGroups.get(selection2);
+  const { active } = selection2;
+  return Promise.allSettled(Array.from(clients, (client) => {
+    const info = dataCubeIndexer.index(client, selection2, active);
+    const filter3 = info ? null : selection2.predicate(client);
+    if (info?.skip || !info && !filter3) return;
+    const query = info?.query(active.predicate) ?? client.query(filter3);
+    return mc.updateClient(client, query);
+  }));
+}
 
 // ../core/src/util/AsyncDispatch.js
 var AsyncDispatch = class {
@@ -14600,7 +14978,7 @@ var AsyncDispatch = class {
    * queue of unemitted event values prior to enqueueing a new value.
    * This default implementation simply returns null, indicating that
    * any other unemitted event values should be dropped (that is, all
-   * queued events are filtered)
+   * queued events are filtered).
    * @param {string} type The event type.
    * @param {*} value The new event value that will be enqueued.
    * @returns {(value: *) => boolean|null} A dispatch queue filter
@@ -14617,6 +14995,16 @@ var AsyncDispatch = class {
     const entry = this._callbacks.get(type2);
     entry?.queue.clear();
   }
+  /**
+   * Returns a promise that resolves when any pending updates complete for
+   * the event of the given type currently being processed. The Promise will
+   * resolve immediately if the queue for the given event type is empty.
+   * @param {string} type The event type to wait for.
+   * @returns {Promise} A pending event promise.
+   */
+  async pending(type2) {
+    await this._callbacks.get(type2)?.pending;
+  }
   /**
    * Emit an event value to listeners for the given event type.
    * If a previous emit has not yet resolved, the event value
@@ -14804,10 +15192,13 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static intersect({ cross: cross3 = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross: cross3 }));
+  static intersect({ cross: cross3 = false, empty: empty4 = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: cross3, empty: empty4 }));
   }
   /**
    * Create a new Selection instance with a
@@ -14816,10 +15207,13 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static union({ cross: cross3 = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross: cross3, union: true }));
+  static union({ cross: cross3 = false, empty: empty4 = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: cross3, empty: empty4, union: true }));
   }
   /**
    * Create a new Selection instance with a singular resolution strategy
@@ -14828,18 +15222,25 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static single({ cross: cross3 = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross: cross3, single: true }));
+  static single({ cross: cross3 = false, empty: empty4 = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: cross3, empty: empty4, single: true }));
   }
   /**
    * Create a new Selection instance with a
    * cross-filtered intersect resolution strategy.
+   * @param {object} [options] The selection options.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static crossfilter() {
-    return new _Selection(new SelectionResolver({ cross: true }));
+  static crossfilter({ empty: empty4 = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: true, empty: empty4 }));
   }
   /**
    * Create a new Selection instance.
@@ -14872,6 +15273,24 @@ var Selection = class _Selection extends Param {
     s2._value.active = { source };
     return s2;
   }
+  /**
+   * The selection clause resolver.
+   */
+  get resolver() {
+    return this._resolver;
+  }
+  /**
+   * Indicate if this selection has a single resolution strategy.
+   */
+  get single() {
+    return this._resolver.single;
+  }
+  /**
+   * The current array of selection clauses.
+   */
+  get clauses() {
+    return super.value;
+  }
   /**
    * The current active (most recently updated) selection clause.
    */
@@ -14886,16 +15305,12 @@ var Selection = class _Selection extends Param {
     return this.active?.value;
   }
   /**
-   * The current array of selection clauses.
+   * The value corresponding to a given source. Returns undefined if
+   * this selection does not include a clause from this source.
+   * @param {*} source The clause source to look up the value for.
    */
-  get clauses() {
-    return super.value;
-  }
-  /**
-   * Indicate if this selection has a single resolution strategy.
-   */
-  get single() {
-    return this._resolver.single;
+  valueFor(source) {
+    return this.clauses.find((c4) => c4.source === source)?.value;
   }
   /**
    * Emit an activate event with the given selection clause.
@@ -14973,11 +15388,15 @@ var SelectionResolver = class {
    *  If false, an intersection strategy is used.
    * @param {boolean} [options.cross=false] Boolean flag to indicate cross-filtering.
    * @param {boolean} [options.single=false] Boolean flag to indicate single clauses only.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    */
-  constructor({ union, cross: cross3, single } = {}) {
+  constructor({ union, cross: cross3, single, empty: empty4 } = {}) {
     this.union = !!union;
     this.cross = !!cross3;
     this.single = !!single;
+    this.empty = !!empty4;
   }
   /**
    * Resolve a list of selection clauses according to the resolution strategy.
@@ -15012,7 +15431,10 @@ var SelectionResolver = class {
    *  based on the current state of this selection.
    */
   predicate(clauseList, active, client) {
-    const { union } = this;
+    const { empty: empty4, union } = this;
+    if (empty4 && !clauseList.length) {
+      return ["FALSE"];
+    }
     if (this.skip(client, active)) return void 0;
     const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
     return union && predicates.length > 1 ? or(predicates) : predicates;
@@ -15032,6 +15454,50 @@ var SelectionResolver = class {
   }
 };
 
+// ../core/src/SelectionClause.js
+function clausePoints(fields, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0
+}) {
+  let predicate = null;
+  if (value) {
+    const clauses = value.map((vals) => {
+      const list = vals.map((v2, i) => isNotDistinct(fields[i], literal(v2)));
+      return list.length > 1 ? and(list) : list[0];
+    });
+    predicate = clauses.length > 1 ? or(clauses) : clauses[0];
+  }
+  return {
+    meta: { type: "point" },
+    source,
+    clients,
+    value,
+    predicate
+  };
+}
+function clauseInterval(field2, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0,
+  bin: bin3,
+  scale: scale3,
+  pixelSize = 1
+}) {
+  const predicate = value != null ? isBetween(field2, value) : null;
+  const meta = { type: "interval", scales: scale3 && [scale3], bin: bin3, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+function clauseIntervals(fields, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0,
+  bin: bin3,
+  scales: scales2 = [],
+  pixelSize = 1
+}) {
+  const predicate = value != null ? and(fields.map((f, i) => isBetween(f, value[i]))) : null;
+  const meta = { type: "interval", scales: scales2, bin: bin3, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+
 // ../core/src/util/synchronizer.js
 function synchronizer() {
   const set3 = /* @__PURE__ */ new Set();
@@ -15076,6 +15542,39 @@ function synchronizer() {
   };
 }
 
+// ../core/src/util/to-data-columns.js
+function toDataColumns(data) {
+  return isArrowTable(data) ? arrowToColumns(data) : arrayToColumns(data);
+}
+function arrowToColumns(data) {
+  const { numRows, numCols, schema: { fields } } = data;
+  const columns = {};
+  for (let col = 0; col < numCols; ++col) {
+    const name = fields[col].name;
+    if (columns[name]) {
+      console.warn(`Redundant column name "${name}". Skipping...`);
+    } else {
+      columns[name] = convertArrowColumn(data.getChildAt(col));
+    }
+  }
+  return { numRows, columns };
+}
+function arrayToColumns(data) {
+  const numRows = data.length;
+  if (typeof data[0] === "object") {
+    const names = numRows ? Object.keys(data[0]) : [];
+    const columns = {};
+    if (names.length > 0) {
+      names.forEach((name) => {
+        columns[name] = data.map((d) => d[name]);
+      });
+    }
+    return { numRows, columns };
+  } else {
+    return { numRows, values: data };
+  }
+}
+
 // ../../node_modules/@observablehq/plot/src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -15147,6 +15646,7 @@ __export(src_exports, {
   find: () => find2,
   formatIsoDate: () => formatIsoDate,
   formatMonth: () => formatMonth,
+  formatNumber: () => formatNumber,
   formatWeekday: () => formatWeekday,
   frame: () => frame2,
   geo: () => geo,
@@ -15186,6 +15686,7 @@ __export(src_exports, {
   normalize: () => normalize3,
   normalizeX: () => normalizeX,
   normalizeY: () => normalizeY,
+  numberInterval: () => numberInterval,
   plot: () => plot,
   pointer: () => pointer,
   pointerX: () => pointerX,
@@ -15221,11 +15722,13 @@ __export(src_exports, {
   textY: () => textY,
   tickX: () => tickX,
   tickY: () => tickY,
+  timeInterval: () => timeInterval2,
   tip: () => tip,
   transform: () => basic,
   tree: () => tree,
   treeLink: () => treeLink,
   treeNode: () => treeNode,
+  utcInterval: () => utcInterval,
   valueof: () => valueof,
   vector: () => vector,
   vectorX: () => vectorX,
@@ -27791,10 +28294,10 @@ function parseTimeInterval(input) {
   if (period > 1 && !interval2.every) throw new Error(`non-periodic interval: ${name}`);
   return [name, period];
 }
-function maybeTimeInterval(input) {
+function timeInterval2(input) {
   return asInterval(parseTimeInterval(input), "time");
 }
-function maybeUtcInterval(input) {
+function utcInterval(input) {
   return asInterval(parseTimeInterval(input), "utc");
 }
 function asInterval([name, period], type2) {
@@ -27812,7 +28315,7 @@ function generalizeTimeInterval(interval2, n) {
   if (!tickIntervals.some(([, d]) => d === duration)) return;
   if (duration % durationDay2 === 0 && durationDay2 < duration && duration < durationMonth2) return;
   const [i] = tickIntervals[bisector(([, step]) => Math.log(step)).center(tickIntervals, Math.log(duration * n))];
-  return (interval2[intervalType] === "time" ? maybeTimeInterval : maybeUtcInterval)(i);
+  return (interval2[intervalType] === "time" ? timeInterval2 : utcInterval)(i);
 }
 function formatTimeInterval(name, type2, anchor) {
   const format3 = type2 === "time" ? timeFormat : utcFormat;
@@ -27877,7 +28380,7 @@ function valueof(data, value, type2) {
   return valueType === "string" ? maybeTypedMap(data, field(value), type2) : valueType === "function" ? maybeTypedMap(data, value, type2) : valueType === "number" || value instanceof Date || valueType === "boolean" ? map2(data, constant(value), type2) : typeof value?.transform === "function" ? maybeTypedArrayify(value.transform(data), type2) : maybeTake(maybeTypedArrayify(value, type2), data?.[reindex]);
 }
 function maybeTake(values2, index2) {
-  return index2 ? take(values2, index2) : values2;
+  return values2 != null && index2 ? take(values2, index2) : values2;
 }
 function maybeTypedMap(data, f, type2) {
   return map2(data, type2?.prototype instanceof TypedArray ? floater(f) : f, type2);
@@ -28048,26 +28551,26 @@ function maybeIntervalTransform(interval2, type2) {
 }
 function maybeInterval(interval2, type2) {
   if (interval2 == null) return;
-  if (typeof interval2 === "number") {
-    if (0 < interval2 && interval2 < 1 && Number.isInteger(1 / interval2)) interval2 = -1 / interval2;
-    const n = Math.abs(interval2);
-    return interval2 < 0 ? {
-      floor: (d) => Math.floor(d * n) / n,
-      offset: (d) => (d * n + 1) / n,
-      // note: no optional step for simplicity
-      range: (lo, hi) => range(Math.ceil(lo * n), hi * n).map((x3) => x3 / n)
-    } : {
-      floor: (d) => Math.floor(d / n) * n,
-      offset: (d) => d + n,
-      // note: no optional step for simplicity
-      range: (lo, hi) => range(Math.ceil(lo / n), hi / n).map((x3) => x3 * n)
-    };
-  }
-  if (typeof interval2 === "string") return (type2 === "time" ? maybeTimeInterval : maybeUtcInterval)(interval2);
+  if (typeof interval2 === "number") return numberInterval(interval2);
+  if (typeof interval2 === "string") return (type2 === "time" ? timeInterval2 : utcInterval)(interval2);
   if (typeof interval2.floor !== "function") throw new Error("invalid interval; missing floor method");
   if (typeof interval2.offset !== "function") throw new Error("invalid interval; missing offset method");
   return interval2;
 }
+function numberInterval(interval2) {
+  interval2 = +interval2;
+  if (0 < interval2 && interval2 < 1 && Number.isInteger(1 / interval2)) interval2 = -1 / interval2;
+  const n = Math.abs(interval2);
+  return interval2 < 0 ? {
+    floor: (d) => Math.floor(d * n) / n,
+    offset: (d, s2 = 1) => (d * n + Math.floor(s2)) / n,
+    range: (lo, hi) => range(Math.ceil(lo * n), hi * n).map((x3) => x3 / n)
+  } : {
+    floor: (d) => Math.floor(d / n) * n,
+    offset: (d, s2 = 1) => d + n * Math.floor(s2),
+    range: (lo, hi) => range(Math.ceil(lo / n), hi / n).map((x3) => x3 * n)
+  };
+}
 function maybeRangeInterval(interval2, type2) {
   interval2 = maybeInterval(interval2, type2);
   if (interval2 && typeof interval2.range !== "function") throw new Error("invalid interval: missing range method");
@@ -28938,251 +29441,6 @@ function getSource(channels, key) {
   return channel.source === null ? null : channel;
 }
 
-// ../../node_modules/@observablehq/plot/src/context.js
-function createContext(options = {}) {
-  const { document: document2 = typeof window !== "undefined" ? window.document : void 0, clip } = options;
-  return { document: document2, clip: maybeClip(clip) };
-}
-function create3(name, { document: document2 }) {
-  return select_default2(creator_default(name).call(document2.documentElement));
-}
-
-// ../../node_modules/@observablehq/plot/src/warnings.js
-var warnings = 0;
-var lastMessage;
-function consumeWarnings() {
-  const w = warnings;
-  warnings = 0;
-  lastMessage = void 0;
-  return w;
-}
-function warn(message) {
-  if (message === lastMessage) return;
-  lastMessage = message;
-  console.warn(message);
-  ++warnings;
-}
-
-// ../../node_modules/@observablehq/plot/src/projection.js
-var pi4 = Math.PI;
-var tau5 = 2 * pi4;
-var defaultAspectRatio = 0.618;
-function createProjection({
-  projection: projection3,
-  inset: globalInset = 0,
-  insetTop = globalInset,
-  insetRight = globalInset,
-  insetBottom = globalInset,
-  insetLeft = globalInset
-} = {}, dimensions) {
-  if (projection3 == null) return;
-  if (typeof projection3.stream === "function") return projection3;
-  let options;
-  let domain;
-  let clip = "frame";
-  if (isObject2(projection3)) {
-    let inset;
-    ({
-      type: projection3,
-      domain,
-      inset,
-      insetTop = inset !== void 0 ? inset : insetTop,
-      insetRight = inset !== void 0 ? inset : insetRight,
-      insetBottom = inset !== void 0 ? inset : insetBottom,
-      insetLeft = inset !== void 0 ? inset : insetLeft,
-      clip = clip,
-      ...options
-    } = projection3);
-    if (projection3 == null) return;
-  }
-  if (typeof projection3 !== "function") ({ type: projection3 } = namedProjection(projection3));
-  const { width, height, marginLeft, marginRight, marginTop, marginBottom } = dimensions;
-  const dx = width - marginLeft - marginRight - insetLeft - insetRight;
-  const dy = height - marginTop - marginBottom - insetTop - insetBottom;
-  projection3 = projection3?.({ width: dx, height: dy, clip, ...options });
-  if (projection3 == null) return;
-  clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);
-  let tx = marginLeft + insetLeft;
-  let ty = marginTop + insetTop;
-  let transform3;
-  if (domain != null) {
-    const [[x06, y06], [x12, y12]] = path_default(projection3).bounds(domain);
-    const k2 = Math.min(dx / (x12 - x06), dy / (y12 - y06));
-    if (k2 > 0) {
-      tx -= (k2 * (x06 + x12) - dx) / 2;
-      ty -= (k2 * (y06 + y12) - dy) / 2;
-      transform3 = transform_default({
-        point(x3, y3) {
-          this.stream.point(x3 * k2 + tx, y3 * k2 + ty);
-        }
-      });
-    } else {
-      warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`);
-    }
-  }
-  transform3 ??= tx === 0 && ty === 0 ? identity8() : transform_default({
-    point(x3, y3) {
-      this.stream.point(x3 + tx, y3 + ty);
-    }
-  });
-  return { stream: (s2) => projection3.stream(transform3.stream(clip(s2))) };
-}
-function namedProjection(projection3) {
-  switch (`${projection3}`.toLowerCase()) {
-    case "albers-usa":
-      return scaleProjection(albersUsa_default, 0.7463, 0.4673);
-    case "albers":
-      return conicProjection2(albers_default, 0.7463, 0.4673);
-    case "azimuthal-equal-area":
-      return scaleProjection(azimuthalEqualArea_default, 4, 4);
-    case "azimuthal-equidistant":
-      return scaleProjection(azimuthalEquidistant_default, tau5, tau5);
-    case "conic-conformal":
-      return conicProjection2(conicConformal_default, tau5, tau5);
-    case "conic-equal-area":
-      return conicProjection2(conicEqualArea_default, 6.1702, 2.9781);
-    case "conic-equidistant":
-      return conicProjection2(conicEquidistant_default, 7.312, 3.6282);
-    case "equal-earth":
-      return scaleProjection(equalEarth_default, 5.4133, 2.6347);
-    case "equirectangular":
-      return scaleProjection(equirectangular_default, tau5, pi4);
-    case "gnomonic":
-      return scaleProjection(gnomonic_default, 3.4641, 3.4641);
-    case "identity":
-      return { type: identity8 };
-    case "reflect-y":
-      return { type: reflectY };
-    case "mercator":
-      return scaleProjection(mercator_default, tau5, tau5);
-    case "orthographic":
-      return scaleProjection(orthographic_default, 2, 2);
-    case "stereographic":
-      return scaleProjection(stereographic_default, 2, 2);
-    case "transverse-mercator":
-      return scaleProjection(transverseMercator_default, tau5, tau5);
-    default:
-      throw new Error(`unknown projection type: ${projection3}`);
-  }
-}
-function maybePostClip(clip, x12, y12, x22, y22) {
-  if (clip === false || clip == null || typeof clip === "number") return (s2) => s2;
-  if (clip === true) clip = "frame";
-  switch (`${clip}`.toLowerCase()) {
-    case "frame":
-      return clipRectangle(x12, y12, x22, y22);
-    default:
-      throw new Error(`unknown projection clip type: ${clip}`);
-  }
-}
-function scaleProjection(createProjection2, kx2, ky2) {
-  return {
-    type: ({ width, height, rotate, precision = 0.15, clip }) => {
-      const projection3 = createProjection2();
-      if (precision != null) projection3.precision?.(precision);
-      if (rotate != null) projection3.rotate?.(rotate);
-      if (typeof clip === "number") projection3.clipAngle?.(clip);
-      projection3.scale(Math.min(width / kx2, height / ky2));
-      projection3.translate([width / 2, height / 2]);
-      return projection3;
-    },
-    aspectRatio: ky2 / kx2
-  };
-}
-function conicProjection2(createProjection2, kx2, ky2) {
-  const { type: type2, aspectRatio } = scaleProjection(createProjection2, kx2, ky2);
-  return {
-    type: (options) => {
-      const { parallels, domain, width, height } = options;
-      const projection3 = type2(options);
-      if (parallels != null) {
-        projection3.parallels(parallels);
-        if (domain === void 0) {
-          projection3.fitSize([width, height], { type: "Sphere" });
-        }
-      }
-      return projection3;
-    },
-    aspectRatio
-  };
-}
-var identity8 = constant({ stream: (stream) => stream });
-var reflectY = constant(
-  transform_default({
-    point(x3, y3) {
-      this.stream.point(x3, -y3);
-    }
-  })
-);
-function project(cx, cy, values2, projection3) {
-  const x3 = values2[cx];
-  const y3 = values2[cy];
-  const n = x3.length;
-  const X3 = values2[cx] = new Float64Array(n).fill(NaN);
-  const Y3 = values2[cy] = new Float64Array(n).fill(NaN);
-  let i;
-  const stream = projection3.stream({
-    point(x4, y4) {
-      X3[i] = x4;
-      Y3[i] = y4;
-    }
-  });
-  for (i = 0; i < n; ++i) {
-    stream.point(x3[i], y3[i]);
-  }
-}
-function hasProjection({ projection: projection3 } = {}) {
-  if (projection3 == null) return false;
-  if (typeof projection3.stream === "function") return true;
-  if (isObject2(projection3)) projection3 = projection3.type;
-  return projection3 != null;
-}
-function projectionAspectRatio(projection3) {
-  if (typeof projection3?.stream === "function") return defaultAspectRatio;
-  if (isObject2(projection3)) projection3 = projection3.type;
-  if (projection3 == null) return;
-  if (typeof projection3 !== "function") {
-    const { aspectRatio } = namedProjection(projection3);
-    if (aspectRatio) return aspectRatio;
-  }
-  return defaultAspectRatio;
-}
-function applyPosition(channels, scales2, { projection: projection3 }) {
-  const { x: x3, y: y3 } = channels;
-  let position3 = {};
-  if (x3) position3.x = x3;
-  if (y3) position3.y = y3;
-  position3 = valueObject(position3, scales2);
-  if (projection3 && x3?.scale === "x" && y3?.scale === "y") project("x", "y", position3, projection3);
-  if (x3) position3.x = coerceNumbers(position3.x);
-  if (y3) position3.y = coerceNumbers(position3.y);
-  return position3;
-}
-function getGeometryChannels(channel) {
-  const X3 = [];
-  const Y3 = [];
-  const x3 = { scale: "x", value: X3 };
-  const y3 = { scale: "y", value: Y3 };
-  const sink = {
-    point(x4, y4) {
-      X3.push(x4);
-      Y3.push(y4);
-    },
-    lineStart() {
-    },
-    lineEnd() {
-    },
-    polygonStart() {
-    },
-    polygonEnd() {
-    },
-    sphere() {
-    }
-  };
-  for (const object of channel.value) stream_default(object, sink);
-  return [x3, y3];
-}
-
 // ../../node_modules/@observablehq/plot/src/scales/schemes.js
 var categoricalSchemes = /* @__PURE__ */ new Map([
   ["accent", Accent_default],
@@ -29427,8 +29685,9 @@ function createScaleQ(key, scale3, channels, {
     const [min5, max4] = extent(domain);
     if (min5 > 0 || max4 < 0) {
       domain = slice3(domain);
-      if (orderof(domain) !== Math.sign(min5)) domain[domain.length - 1] = 0;
-      else domain[0] = 0;
+      const o = orderof(domain) || 1;
+      if (o === Math.sign(min5)) domain[0] = 0;
+      else domain[domain.length - 1] = 0;
     }
   }
   if (reverse3) domain = reverse(domain);
@@ -29579,6 +29838,22 @@ function interpolatePiecewise(interpolate) {
   return (i, j) => (t) => interpolate(i + t * (j - i));
 }
 
+// ../../node_modules/@observablehq/plot/src/warnings.js
+var warnings = 0;
+var lastMessage;
+function consumeWarnings() {
+  const w = warnings;
+  warnings = 0;
+  lastMessage = void 0;
+  return w;
+}
+function warn(message) {
+  if (message === lastMessage) return;
+  lastMessage = message;
+  console.warn(message);
+  ++warnings;
+}
+
 // ../../node_modules/@observablehq/plot/src/scales/diverging.js
 function createScaleD(key, scale3, transform3, channels, {
   type: type2,
@@ -30234,6 +30509,373 @@ function exposeScale({ scale: scale3, type: type2, domain, range: range3, interp
   };
 }
 
+// ../../node_modules/@observablehq/plot/src/facet.js
+function createFacets(channelsByScale, options) {
+  const { fx, fy } = createScales(channelsByScale, options);
+  const fxDomain = fx?.scale.domain();
+  const fyDomain = fy?.scale.domain();
+  return fxDomain && fyDomain ? cross(fxDomain, fyDomain).map(([x3, y3], i) => ({ x: x3, y: y3, i })) : fxDomain ? fxDomain.map((x3, i) => ({ x: x3, i })) : fyDomain ? fyDomain.map((y3, i) => ({ y: y3, i })) : void 0;
+}
+function recreateFacets(facets, { x: X3, y: Y3 }) {
+  X3 &&= facetIndex(X3);
+  Y3 &&= facetIndex(Y3);
+  return facets.filter(
+    X3 && Y3 ? (f) => X3.has(f.x) && Y3.has(f.y) : X3 ? (f) => X3.has(f.x) : (f) => Y3.has(f.y)
+  ).sort(
+    X3 && Y3 ? (a2, b) => X3.get(a2.x) - X3.get(b.x) || Y3.get(a2.y) - Y3.get(b.y) : X3 ? (a2, b) => X3.get(a2.x) - X3.get(b.x) : (a2, b) => Y3.get(a2.y) - Y3.get(b.y)
+  );
+}
+function facetGroups(data, { fx, fy }) {
+  const I = range2(data);
+  const FX = fx?.value;
+  const FY = fy?.value;
+  return fx && fy ? rollup(
+    I,
+    (G) => (G.fx = FX[G[0]], G.fy = FY[G[0]], G),
+    (i) => FX[i],
+    (i) => FY[i]
+  ) : fx ? rollup(
+    I,
+    (G) => (G.fx = FX[G[0]], G),
+    (i) => FX[i]
+  ) : rollup(
+    I,
+    (G) => (G.fy = FY[G[0]], G),
+    (i) => FY[i]
+  );
+}
+function facetTranslator(fx, fy, { marginTop, marginLeft }) {
+  return fx && fy ? ({ x: x3, y: y3 }) => `translate(${fx(x3) - marginLeft},${fy(y3) - marginTop})` : fx ? ({ x: x3 }) => `translate(${fx(x3) - marginLeft},0)` : ({ y: y3 }) => `translate(0,${fy(y3) - marginTop})`;
+}
+function facetExclude(index2) {
+  const ex = [];
+  const e = new Uint32Array(sum2(index2, (d) => d.length));
+  for (const i of index2) {
+    let n = 0;
+    for (const j of index2) {
+      if (i === j) continue;
+      e.set(j, n);
+      n += j.length;
+    }
+    ex.push(e.slice(0, n));
+  }
+  return ex;
+}
+var facetAnchors = /* @__PURE__ */ new Map([
+  ["top", facetAnchorTop],
+  ["right", facetAnchorRight],
+  ["bottom", facetAnchorBottom],
+  ["left", facetAnchorLeft],
+  ["top-left", and2(facetAnchorTop, facetAnchorLeft)],
+  ["top-right", and2(facetAnchorTop, facetAnchorRight)],
+  ["bottom-left", and2(facetAnchorBottom, facetAnchorLeft)],
+  ["bottom-right", and2(facetAnchorBottom, facetAnchorRight)],
+  ["top-empty", facetAnchorTopEmpty],
+  ["right-empty", facetAnchorRightEmpty],
+  ["bottom-empty", facetAnchorBottomEmpty],
+  ["left-empty", facetAnchorLeftEmpty],
+  ["empty", facetAnchorEmpty]
+]);
+function maybeFacetAnchor(facetAnchor) {
+  if (facetAnchor == null) return null;
+  const anchor = facetAnchors.get(`${facetAnchor}`.toLowerCase());
+  if (anchor) return anchor;
+  throw new Error(`invalid facet anchor: ${facetAnchor}`);
+}
+var indexCache = /* @__PURE__ */ new WeakMap();
+function facetIndex(V) {
+  let I = indexCache.get(V);
+  if (!I) indexCache.set(V, I = new InternMap(map2(V, (v2, i) => [v2, i])));
+  return I;
+}
+function facetIndexOf(V, v2) {
+  return facetIndex(V).get(v2);
+}
+function facetFind(facets, x3, y3) {
+  x3 = keyof2(x3);
+  y3 = keyof2(y3);
+  return facets.find((f) => Object.is(keyof2(f.x), x3) && Object.is(keyof2(f.y), y3));
+}
+function facetEmpty(facets, x3, y3) {
+  return facetFind(facets, x3, y3)?.empty;
+}
+function facetAnchorTop(facets, { y: Y3 }, { y: y3 }) {
+  return Y3 ? facetIndexOf(Y3, y3) === 0 : true;
+}
+function facetAnchorBottom(facets, { y: Y3 }, { y: y3 }) {
+  return Y3 ? facetIndexOf(Y3, y3) === Y3.length - 1 : true;
+}
+function facetAnchorLeft(facets, { x: X3 }, { x: x3 }) {
+  return X3 ? facetIndexOf(X3, x3) === 0 : true;
+}
+function facetAnchorRight(facets, { x: X3 }, { x: x3 }) {
+  return X3 ? facetIndexOf(X3, x3) === X3.length - 1 : true;
+}
+function facetAnchorTopEmpty(facets, { y: Y3 }, { x: x3, y: y3, empty: empty4 }) {
+  if (empty4) return false;
+  if (!Y3) return;
+  const i = facetIndexOf(Y3, y3);
+  if (i > 0) return facetEmpty(facets, x3, Y3[i - 1]);
+}
+function facetAnchorBottomEmpty(facets, { y: Y3 }, { x: x3, y: y3, empty: empty4 }) {
+  if (empty4) return false;
+  if (!Y3) return;
+  const i = facetIndexOf(Y3, y3);
+  if (i < Y3.length - 1) return facetEmpty(facets, x3, Y3[i + 1]);
+}
+function facetAnchorLeftEmpty(facets, { x: X3 }, { x: x3, y: y3, empty: empty4 }) {
+  if (empty4) return false;
+  if (!X3) return;
+  const i = facetIndexOf(X3, x3);
+  if (i > 0) return facetEmpty(facets, X3[i - 1], y3);
+}
+function facetAnchorRightEmpty(facets, { x: X3 }, { x: x3, y: y3, empty: empty4 }) {
+  if (empty4) return false;
+  if (!X3) return;
+  const i = facetIndexOf(X3, x3);
+  if (i < X3.length - 1) return facetEmpty(facets, X3[i + 1], y3);
+}
+function facetAnchorEmpty(facets, channels, { empty: empty4 }) {
+  return empty4;
+}
+function and2(a2, b) {
+  return function() {
+    return a2.apply(null, arguments) && b.apply(null, arguments);
+  };
+}
+function facetFilter(facets, { channels: { fx, fy }, groups: groups2 }) {
+  return fx && fy ? facets.map(({ x: x3, y: y3 }) => groups2.get(x3)?.get(y3) ?? []) : fx ? facets.map(({ x: x3 }) => groups2.get(x3) ?? []) : facets.map(({ y: y3 }) => groups2.get(y3) ?? []);
+}
+
+// ../../node_modules/@observablehq/plot/src/projection.js
+var pi4 = Math.PI;
+var tau5 = 2 * pi4;
+var defaultAspectRatio = 0.618;
+function createProjection({
+  projection: projection3,
+  inset: globalInset = 0,
+  insetTop = globalInset,
+  insetRight = globalInset,
+  insetBottom = globalInset,
+  insetLeft = globalInset
+} = {}, dimensions) {
+  if (projection3 == null) return;
+  if (typeof projection3.stream === "function") return projection3;
+  let options;
+  let domain;
+  let clip = "frame";
+  if (isObject2(projection3)) {
+    let inset;
+    ({
+      type: projection3,
+      domain,
+      inset,
+      insetTop = inset !== void 0 ? inset : insetTop,
+      insetRight = inset !== void 0 ? inset : insetRight,
+      insetBottom = inset !== void 0 ? inset : insetBottom,
+      insetLeft = inset !== void 0 ? inset : insetLeft,
+      clip = clip,
+      ...options
+    } = projection3);
+    if (projection3 == null) return;
+  }
+  if (typeof projection3 !== "function") ({ type: projection3 } = namedProjection(projection3));
+  const { width, height, marginLeft, marginRight, marginTop, marginBottom } = dimensions;
+  const dx = width - marginLeft - marginRight - insetLeft - insetRight;
+  const dy = height - marginTop - marginBottom - insetTop - insetBottom;
+  projection3 = projection3?.({ width: dx, height: dy, clip, ...options });
+  if (projection3 == null) return;
+  clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);
+  let tx = marginLeft + insetLeft;
+  let ty = marginTop + insetTop;
+  let transform3;
+  if (domain != null) {
+    const [[x06, y06], [x12, y12]] = path_default(projection3).bounds(domain);
+    const k2 = Math.min(dx / (x12 - x06), dy / (y12 - y06));
+    if (k2 > 0) {
+      tx -= (k2 * (x06 + x12) - dx) / 2;
+      ty -= (k2 * (y06 + y12) - dy) / 2;
+      transform3 = transform_default({
+        point(x3, y3) {
+          this.stream.point(x3 * k2 + tx, y3 * k2 + ty);
+        }
+      });
+    } else {
+      warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`);
+    }
+  }
+  transform3 ??= tx === 0 && ty === 0 ? identity8() : transform_default({
+    point(x3, y3) {
+      this.stream.point(x3 + tx, y3 + ty);
+    }
+  });
+  return { stream: (s2) => projection3.stream(transform3.stream(clip(s2))) };
+}
+function namedProjection(projection3) {
+  switch (`${projection3}`.toLowerCase()) {
+    case "albers-usa":
+      return scaleProjection(albersUsa_default, 0.7463, 0.4673);
+    case "albers":
+      return conicProjection2(albers_default, 0.7463, 0.4673);
+    case "azimuthal-equal-area":
+      return scaleProjection(azimuthalEqualArea_default, 4, 4);
+    case "azimuthal-equidistant":
+      return scaleProjection(azimuthalEquidistant_default, tau5, tau5);
+    case "conic-conformal":
+      return conicProjection2(conicConformal_default, tau5, tau5);
+    case "conic-equal-area":
+      return conicProjection2(conicEqualArea_default, 6.1702, 2.9781);
+    case "conic-equidistant":
+      return conicProjection2(conicEquidistant_default, 7.312, 3.6282);
+    case "equal-earth":
+      return scaleProjection(equalEarth_default, 5.4133, 2.6347);
+    case "equirectangular":
+      return scaleProjection(equirectangular_default, tau5, pi4);
+    case "gnomonic":
+      return scaleProjection(gnomonic_default, 3.4641, 3.4641);
+    case "identity":
+      return { type: identity8 };
+    case "reflect-y":
+      return { type: reflectY };
+    case "mercator":
+      return scaleProjection(mercator_default, tau5, tau5);
+    case "orthographic":
+      return scaleProjection(orthographic_default, 2, 2);
+    case "stereographic":
+      return scaleProjection(stereographic_default, 2, 2);
+    case "transverse-mercator":
+      return scaleProjection(transverseMercator_default, tau5, tau5);
+    default:
+      throw new Error(`unknown projection type: ${projection3}`);
+  }
+}
+function maybePostClip(clip, x12, y12, x22, y22) {
+  if (clip === false || clip == null || typeof clip === "number") return (s2) => s2;
+  if (clip === true) clip = "frame";
+  switch (`${clip}`.toLowerCase()) {
+    case "frame":
+      return clipRectangle(x12, y12, x22, y22);
+    default:
+      throw new Error(`unknown projection clip type: ${clip}`);
+  }
+}
+function scaleProjection(createProjection2, kx2, ky2) {
+  return {
+    type: ({ width, height, rotate, precision = 0.15, clip }) => {
+      const projection3 = createProjection2();
+      if (precision != null) projection3.precision?.(precision);
+      if (rotate != null) projection3.rotate?.(rotate);
+      if (typeof clip === "number") projection3.clipAngle?.(clip);
+      projection3.scale(Math.min(width / kx2, height / ky2));
+      projection3.translate([width / 2, height / 2]);
+      return projection3;
+    },
+    aspectRatio: ky2 / kx2
+  };
+}
+function conicProjection2(createProjection2, kx2, ky2) {
+  const { type: type2, aspectRatio } = scaleProjection(createProjection2, kx2, ky2);
+  return {
+    type: (options) => {
+      const { parallels, domain, width, height } = options;
+      const projection3 = type2(options);
+      if (parallels != null) {
+        projection3.parallels(parallels);
+        if (domain === void 0) {
+          projection3.fitSize([width, height], { type: "Sphere" });
+        }
+      }
+      return projection3;
+    },
+    aspectRatio
+  };
+}
+var identity8 = constant({ stream: (stream) => stream });
+var reflectY = constant(
+  transform_default({
+    point(x3, y3) {
+      this.stream.point(x3, -y3);
+    }
+  })
+);
+function project(cx, cy, values2, projection3) {
+  const x3 = values2[cx];
+  const y3 = values2[cy];
+  const n = x3.length;
+  const X3 = values2[cx] = new Float64Array(n).fill(NaN);
+  const Y3 = values2[cy] = new Float64Array(n).fill(NaN);
+  let i;
+  const stream = projection3.stream({
+    point(x4, y4) {
+      X3[i] = x4;
+      Y3[i] = y4;
+    }
+  });
+  for (i = 0; i < n; ++i) {
+    stream.point(x3[i], y3[i]);
+  }
+}
+function hasProjection({ projection: projection3 } = {}) {
+  if (projection3 == null) return false;
+  if (typeof projection3.stream === "function") return true;
+  if (isObject2(projection3)) projection3 = projection3.type;
+  return projection3 != null;
+}
+function projectionAspectRatio(projection3) {
+  if (typeof projection3?.stream === "function") return defaultAspectRatio;
+  if (isObject2(projection3)) projection3 = projection3.type;
+  if (projection3 == null) return;
+  if (typeof projection3 !== "function") {
+    const { aspectRatio } = namedProjection(projection3);
+    if (aspectRatio) return aspectRatio;
+  }
+  return defaultAspectRatio;
+}
+function applyPosition(channels, scales2, { projection: projection3 }) {
+  const { x: x3, y: y3 } = channels;
+  let position3 = {};
+  if (x3) position3.x = x3;
+  if (y3) position3.y = y3;
+  position3 = valueObject(position3, scales2);
+  if (projection3 && x3?.scale === "x" && y3?.scale === "y") project("x", "y", position3, projection3);
+  if (x3) position3.x = coerceNumbers(position3.x);
+  if (y3) position3.y = coerceNumbers(position3.y);
+  return position3;
+}
+function getGeometryChannels(channel) {
+  const X3 = [];
+  const Y3 = [];
+  const x3 = { scale: "x", value: X3 };
+  const y3 = { scale: "y", value: Y3 };
+  const sink = {
+    point(x4, y4) {
+      X3.push(x4);
+      Y3.push(y4);
+    },
+    lineStart() {
+    },
+    lineEnd() {
+    },
+    polygonStart() {
+    },
+    polygonEnd() {
+    },
+    sphere() {
+    }
+  };
+  for (const object of channel.value) stream_default(object, sink);
+  return [x3, y3];
+}
+
+// ../../node_modules/@observablehq/plot/src/context.js
+function createContext(options = {}) {
+  const { document: document2 = typeof window !== "undefined" ? window.document : void 0, clip } = options;
+  return { document: document2, clip: maybeClip(clip) };
+}
+function create3(name, { document: document2 }) {
+  return select_default2(creator_default(name).call(document2.documentElement));
+}
+
 // ../../node_modules/@observablehq/plot/src/memoize.js
 function memoize1(compute) {
   let cacheValue, cacheKeys;
@@ -30598,6 +31240,153 @@ function applyFrameAnchor({ frameAnchor }, { width, height, marginTop, marginRig
   ];
 }
 
+// ../../node_modules/@observablehq/plot/src/mark.js
+var Mark = class {
+  constructor(data, channels = {}, options = {}, defaults23) {
+    const {
+      facet = "auto",
+      facetAnchor,
+      fx,
+      fy,
+      sort: sort3,
+      dx = 0,
+      dy = 0,
+      margin = 0,
+      marginTop = margin,
+      marginRight = margin,
+      marginBottom = margin,
+      marginLeft = margin,
+      clip = defaults23?.clip,
+      channels: extraChannels,
+      tip: tip2,
+      render
+    } = options;
+    this.data = data;
+    this.sort = isDomainSort(sort3) ? sort3 : null;
+    this.initializer = initializer(options).initializer;
+    this.transform = this.initializer ? options.transform : basic(options).transform;
+    if (facet === null || facet === false) {
+      this.facet = null;
+    } else {
+      this.facet = keyword(facet === true ? "include" : facet, "facet", ["auto", "include", "exclude", "super"]);
+      this.fx = data === singleton && typeof fx === "string" ? [fx] : fx;
+      this.fy = data === singleton && typeof fy === "string" ? [fy] : fy;
+    }
+    this.facetAnchor = maybeFacetAnchor(facetAnchor);
+    channels = maybeNamed(channels);
+    if (extraChannels !== void 0) channels = { ...maybeChannels(extraChannels), ...channels };
+    if (defaults23 !== void 0) channels = { ...styles(this, options, defaults23), ...channels };
+    this.channels = Object.fromEntries(
+      Object.entries(channels).map(([name, channel]) => {
+        if (isOptions(channel.value)) {
+          const { value, label = channel.label, scale: scale3 = channel.scale } = channel.value;
+          channel = { ...channel, label, scale: scale3, value };
+        }
+        if (data === singleton && typeof channel.value === "string") {
+          const { value } = channel;
+          channel = { ...channel, value: [value] };
+        }
+        return [name, channel];
+      }).filter(([name, { value, optional: optional2 }]) => {
+        if (value != null) return true;
+        if (optional2) return false;
+        throw new Error(`missing channel value: ${name}`);
+      })
+    );
+    this.dx = +dx;
+    this.dy = +dy;
+    this.marginTop = +marginTop;
+    this.marginRight = +marginRight;
+    this.marginBottom = +marginBottom;
+    this.marginLeft = +marginLeft;
+    this.clip = maybeClip(clip);
+    this.tip = maybeTip(tip2);
+    if (this.facet === "super") {
+      if (fx || fy) throw new Error(`super-faceting cannot use fx or fy`);
+      for (const name in this.channels) {
+        const { scale: scale3 } = channels[name];
+        if (scale3 !== "x" && scale3 !== "y") continue;
+        throw new Error(`super-faceting cannot use x or y`);
+      }
+    }
+    if (render != null) {
+      this.render = composeRender(render, this.render);
+    }
+  }
+  initialize(facets, facetChannels, plotOptions) {
+    let data = arrayify2(this.data);
+    if (facets === void 0 && data != null) facets = [range2(data)];
+    const originalFacets = facets;
+    if (this.transform != null) ({ facets, data } = this.transform(data, facets, plotOptions)), data = arrayify2(data);
+    if (facets !== void 0) facets.original = originalFacets;
+    const channels = createChannels(this.channels, data);
+    if (this.sort != null) channelDomain(data, facets, channels, facetChannels, this.sort);
+    return { data, facets, channels };
+  }
+  filter(index2, channels, values2) {
+    for (const name in channels) {
+      const { filter: filter3 = defined } = channels[name];
+      if (filter3 !== null) {
+        const value = values2[name];
+        index2 = index2.filter((i) => filter3(value[i]));
+      }
+    }
+    return index2;
+  }
+  // If there is a projection, and there are paired x and y channels associated
+  // with the x and y scale respectively (and not already in screen coordinates
+  // as with an initializer), then apply the projection, replacing the x and y
+  // values. Note that the x and y scales themselves don’t exist if there is a
+  // projection, but whether the channels are associated with scales still
+  // determines whether the projection should apply; think of the projection as
+  // a combination xy-scale.
+  project(channels, values2, context) {
+    for (const cx in channels) {
+      if (channels[cx].scale === "x" && /^x|x$/.test(cx)) {
+        const cy = cx.replace(/^x|x$/, "y");
+        if (cy in channels && channels[cy].scale === "y") {
+          project(cx, cy, values2, context.projection);
+        }
+      }
+    }
+  }
+  scale(channels, scales2, context) {
+    const values2 = valueObject(channels, scales2);
+    if (context.projection) this.project(channels, values2, context);
+    return values2;
+  }
+};
+function marks(...marks2) {
+  marks2.plot = Mark.prototype.plot;
+  return marks2;
+}
+function composeRender(r1, r2) {
+  if (r1 == null) return r2 === null ? void 0 : r2;
+  if (r2 == null) return r1 === null ? void 0 : r1;
+  if (typeof r1 !== "function") throw new TypeError(`invalid render transform: ${r1}`);
+  if (typeof r2 !== "function") throw new TypeError(`invalid render transform: ${r2}`);
+  return function(i, s2, v2, d, c4, next) {
+    return r1.call(this, i, s2, v2, d, c4, (i2, s3, v3, d2, c5) => {
+      return r2.call(this, i2, s3, v3, d2, c5, next);
+    });
+  };
+}
+function maybeChannels(channels) {
+  return Object.fromEntries(
+    Object.entries(maybeNamed(channels)).map(([name, channel]) => {
+      channel = typeof channel === "string" ? { value: channel, label: name } : maybeValue(channel);
+      if (channel.filter === void 0 && channel.scale == null) channel = { ...channel, filter: null };
+      return [name, channel];
+    })
+  );
+}
+function maybeTip(tip2) {
+  return tip2 === true ? "xy" : tip2 === false || tip2 == null ? null : typeof tip2 === "string" ? keyword(tip2, "tip", ["x", "y", "xy"]) : tip2;
+}
+function withTip(options, pointer2) {
+  return options?.tip === true ? { ...options, tip: pointer2 } : isObject2(options?.tip) && options.tip.pointer === void 0 ? { ...options, tip: { ...options.tip, pointer: pointer2 } } : options;
+}
+
 // ../../node_modules/@observablehq/plot/src/dimensions.js
 function createDimensions(scales2, marks2, options = {}) {
   let marginTopDefault = 0.5 - offset, marginRightDefault = 0.5 + offset, marginBottomDefault = 0.5 + offset, marginLeftDefault = 0.5 - offset;
@@ -30708,291 +31497,6 @@ function aspectRatioLength(k2, scale3) {
   return Math.abs(transform3(max4) - transform3(min5));
 }
 
-// ../../node_modules/@observablehq/plot/src/facet.js
-function createFacets(channelsByScale, options) {
-  const { fx, fy } = createScales(channelsByScale, options);
-  const fxDomain = fx?.scale.domain();
-  const fyDomain = fy?.scale.domain();
-  return fxDomain && fyDomain ? cross(fxDomain, fyDomain).map(([x3, y3], i) => ({ x: x3, y: y3, i })) : fxDomain ? fxDomain.map((x3, i) => ({ x: x3, i })) : fyDomain ? fyDomain.map((y3, i) => ({ y: y3, i })) : void 0;
-}
-function recreateFacets(facets, { x: X3, y: Y3 }) {
-  X3 &&= facetIndex(X3);
-  Y3 &&= facetIndex(Y3);
-  return facets.filter(
-    X3 && Y3 ? (f) => X3.has(f.x) && Y3.has(f.y) : X3 ? (f) => X3.has(f.x) : (f) => Y3.has(f.y)
-  ).sort(
-    X3 && Y3 ? (a2, b) => X3.get(a2.x) - X3.get(b.x) || Y3.get(a2.y) - Y3.get(b.y) : X3 ? (a2, b) => X3.get(a2.x) - X3.get(b.x) : (a2, b) => Y3.get(a2.y) - Y3.get(b.y)
-  );
-}
-function facetGroups(data, { fx, fy }) {
-  const I = range2(data);
-  const FX = fx?.value;
-  const FY = fy?.value;
-  return fx && fy ? rollup(
-    I,
-    (G) => (G.fx = FX[G[0]], G.fy = FY[G[0]], G),
-    (i) => FX[i],
-    (i) => FY[i]
-  ) : fx ? rollup(
-    I,
-    (G) => (G.fx = FX[G[0]], G),
-    (i) => FX[i]
-  ) : rollup(
-    I,
-    (G) => (G.fy = FY[G[0]], G),
-    (i) => FY[i]
-  );
-}
-function facetTranslator(fx, fy, { marginTop, marginLeft }) {
-  return fx && fy ? ({ x: x3, y: y3 }) => `translate(${fx(x3) - marginLeft},${fy(y3) - marginTop})` : fx ? ({ x: x3 }) => `translate(${fx(x3) - marginLeft},0)` : ({ y: y3 }) => `translate(0,${fy(y3) - marginTop})`;
-}
-function facetExclude(index2) {
-  const ex = [];
-  const e = new Uint32Array(sum2(index2, (d) => d.length));
-  for (const i of index2) {
-    let n = 0;
-    for (const j of index2) {
-      if (i === j) continue;
-      e.set(j, n);
-      n += j.length;
-    }
-    ex.push(e.slice(0, n));
-  }
-  return ex;
-}
-var facetAnchors = /* @__PURE__ */ new Map([
-  ["top", facetAnchorTop],
-  ["right", facetAnchorRight],
-  ["bottom", facetAnchorBottom],
-  ["left", facetAnchorLeft],
-  ["top-left", and2(facetAnchorTop, facetAnchorLeft)],
-  ["top-right", and2(facetAnchorTop, facetAnchorRight)],
-  ["bottom-left", and2(facetAnchorBottom, facetAnchorLeft)],
-  ["bottom-right", and2(facetAnchorBottom, facetAnchorRight)],
-  ["top-empty", facetAnchorTopEmpty],
-  ["right-empty", facetAnchorRightEmpty],
-  ["bottom-empty", facetAnchorBottomEmpty],
-  ["left-empty", facetAnchorLeftEmpty],
-  ["empty", facetAnchorEmpty]
-]);
-function maybeFacetAnchor(facetAnchor) {
-  if (facetAnchor == null) return null;
-  const anchor = facetAnchors.get(`${facetAnchor}`.toLowerCase());
-  if (anchor) return anchor;
-  throw new Error(`invalid facet anchor: ${facetAnchor}`);
-}
-var indexCache = /* @__PURE__ */ new WeakMap();
-function facetIndex(V) {
-  let I = indexCache.get(V);
-  if (!I) indexCache.set(V, I = new InternMap(map2(V, (v2, i) => [v2, i])));
-  return I;
-}
-function facetIndexOf(V, v2) {
-  return facetIndex(V).get(v2);
-}
-function facetFind(facets, x3, y3) {
-  x3 = keyof2(x3);
-  y3 = keyof2(y3);
-  return facets.find((f) => Object.is(keyof2(f.x), x3) && Object.is(keyof2(f.y), y3));
-}
-function facetEmpty(facets, x3, y3) {
-  return facetFind(facets, x3, y3)?.empty;
-}
-function facetAnchorTop(facets, { y: Y3 }, { y: y3 }) {
-  return Y3 ? facetIndexOf(Y3, y3) === 0 : true;
-}
-function facetAnchorBottom(facets, { y: Y3 }, { y: y3 }) {
-  return Y3 ? facetIndexOf(Y3, y3) === Y3.length - 1 : true;
-}
-function facetAnchorLeft(facets, { x: X3 }, { x: x3 }) {
-  return X3 ? facetIndexOf(X3, x3) === 0 : true;
-}
-function facetAnchorRight(facets, { x: X3 }, { x: x3 }) {
-  return X3 ? facetIndexOf(X3, x3) === X3.length - 1 : true;
-}
-function facetAnchorTopEmpty(facets, { y: Y3 }, { x: x3, y: y3, empty: empty4 }) {
-  if (empty4) return false;
-  if (!Y3) return;
-  const i = facetIndexOf(Y3, y3);
-  if (i > 0) return facetEmpty(facets, x3, Y3[i - 1]);
-}
-function facetAnchorBottomEmpty(facets, { y: Y3 }, { x: x3, y: y3, empty: empty4 }) {
-  if (empty4) return false;
-  if (!Y3) return;
-  const i = facetIndexOf(Y3, y3);
-  if (i < Y3.length - 1) return facetEmpty(facets, x3, Y3[i + 1]);
-}
-function facetAnchorLeftEmpty(facets, { x: X3 }, { x: x3, y: y3, empty: empty4 }) {
-  if (empty4) return false;
-  if (!X3) return;
-  const i = facetIndexOf(X3, x3);
-  if (i > 0) return facetEmpty(facets, X3[i - 1], y3);
-}
-function facetAnchorRightEmpty(facets, { x: X3 }, { x: x3, y: y3, empty: empty4 }) {
-  if (empty4) return false;
-  if (!X3) return;
-  const i = facetIndexOf(X3, x3);
-  if (i < X3.length - 1) return facetEmpty(facets, X3[i + 1], y3);
-}
-function facetAnchorEmpty(facets, channels, { empty: empty4 }) {
-  return empty4;
-}
-function and2(a2, b) {
-  return function() {
-    return a2.apply(null, arguments) && b.apply(null, arguments);
-  };
-}
-function facetFilter(facets, { channels: { fx, fy }, groups: groups2 }) {
-  return fx && fy ? facets.map(({ x: x3, y: y3 }) => groups2.get(x3)?.get(y3) ?? []) : fx ? facets.map(({ x: x3 }) => groups2.get(x3) ?? []) : facets.map(({ y: y3 }) => groups2.get(y3) ?? []);
-}
-
-// ../../node_modules/@observablehq/plot/src/mark.js
-var Mark = class {
-  constructor(data, channels = {}, options = {}, defaults23) {
-    const {
-      facet = "auto",
-      facetAnchor,
-      fx,
-      fy,
-      sort: sort3,
-      dx = 0,
-      dy = 0,
-      margin = 0,
-      marginTop = margin,
-      marginRight = margin,
-      marginBottom = margin,
-      marginLeft = margin,
-      clip = defaults23?.clip,
-      channels: extraChannels,
-      tip: tip2,
-      render
-    } = options;
-    this.data = data;
-    this.sort = isDomainSort(sort3) ? sort3 : null;
-    this.initializer = initializer(options).initializer;
-    this.transform = this.initializer ? options.transform : basic(options).transform;
-    if (facet === null || facet === false) {
-      this.facet = null;
-    } else {
-      this.facet = keyword(facet === true ? "include" : facet, "facet", ["auto", "include", "exclude", "super"]);
-      this.fx = data === singleton && typeof fx === "string" ? [fx] : fx;
-      this.fy = data === singleton && typeof fy === "string" ? [fy] : fy;
-    }
-    this.facetAnchor = maybeFacetAnchor(facetAnchor);
-    channels = maybeNamed(channels);
-    if (extraChannels !== void 0) channels = { ...maybeChannels(extraChannels), ...channels };
-    if (defaults23 !== void 0) channels = { ...styles(this, options, defaults23), ...channels };
-    this.channels = Object.fromEntries(
-      Object.entries(channels).map(([name, channel]) => {
-        if (isOptions(channel.value)) {
-          const { value, label = channel.label, scale: scale3 = channel.scale } = channel.value;
-          channel = { ...channel, label, scale: scale3, value };
-        }
-        if (data === singleton && typeof channel.value === "string") {
-          const { value } = channel;
-          channel = { ...channel, value: [value] };
-        }
-        return [name, channel];
-      }).filter(([name, { value, optional: optional2 }]) => {
-        if (value != null) return true;
-        if (optional2) return false;
-        throw new Error(`missing channel value: ${name}`);
-      })
-    );
-    this.dx = +dx;
-    this.dy = +dy;
-    this.marginTop = +marginTop;
-    this.marginRight = +marginRight;
-    this.marginBottom = +marginBottom;
-    this.marginLeft = +marginLeft;
-    this.clip = maybeClip(clip);
-    this.tip = maybeTip(tip2);
-    if (this.facet === "super") {
-      if (fx || fy) throw new Error(`super-faceting cannot use fx or fy`);
-      for (const name in this.channels) {
-        const { scale: scale3 } = channels[name];
-        if (scale3 !== "x" && scale3 !== "y") continue;
-        throw new Error(`super-faceting cannot use x or y`);
-      }
-    }
-    if (render != null) {
-      this.render = composeRender(render, this.render);
-    }
-  }
-  initialize(facets, facetChannels, plotOptions) {
-    let data = arrayify2(this.data);
-    if (facets === void 0 && data != null) facets = [range2(data)];
-    const originalFacets = facets;
-    if (this.transform != null) ({ facets, data } = this.transform(data, facets, plotOptions)), data = arrayify2(data);
-    if (facets !== void 0) facets.original = originalFacets;
-    const channels = createChannels(this.channels, data);
-    if (this.sort != null) channelDomain(data, facets, channels, facetChannels, this.sort);
-    return { data, facets, channels };
-  }
-  filter(index2, channels, values2) {
-    for (const name in channels) {
-      const { filter: filter3 = defined } = channels[name];
-      if (filter3 !== null) {
-        const value = values2[name];
-        index2 = index2.filter((i) => filter3(value[i]));
-      }
-    }
-    return index2;
-  }
-  // If there is a projection, and there are paired x and y channels associated
-  // with the x and y scale respectively (and not already in screen coordinates
-  // as with an initializer), then apply the projection, replacing the x and y
-  // values. Note that the x and y scales themselves don’t exist if there is a
-  // projection, but whether the channels are associated with scales still
-  // determines whether the projection should apply; think of the projection as
-  // a combination xy-scale.
-  project(channels, values2, context) {
-    for (const cx in channels) {
-      if (channels[cx].scale === "x" && /^x|x$/.test(cx)) {
-        const cy = cx.replace(/^x|x$/, "y");
-        if (cy in channels && channels[cy].scale === "y") {
-          project(cx, cy, values2, context.projection);
-        }
-      }
-    }
-  }
-  scale(channels, scales2, context) {
-    const values2 = valueObject(channels, scales2);
-    if (context.projection) this.project(channels, values2, context);
-    return values2;
-  }
-};
-function marks(...marks2) {
-  marks2.plot = Mark.prototype.plot;
-  return marks2;
-}
-function composeRender(r1, r2) {
-  if (r1 == null) return r2 === null ? void 0 : r2;
-  if (r2 == null) return r1 === null ? void 0 : r1;
-  if (typeof r1 !== "function") throw new TypeError(`invalid render transform: ${r1}`);
-  if (typeof r2 !== "function") throw new TypeError(`invalid render transform: ${r2}`);
-  return function(i, s2, v2, d, c4, next) {
-    return r1.call(this, i, s2, v2, d, c4, (i2, s3, v3, d2, c5) => {
-      return r2.call(this, i2, s3, v3, d2, c5, next);
-    });
-  };
-}
-function maybeChannels(channels) {
-  return Object.fromEntries(
-    Object.entries(maybeNamed(channels)).map(([name, channel]) => {
-      channel = typeof channel === "string" ? { value: channel, label: name } : maybeValue(channel);
-      if (channel.filter === void 0 && channel.scale == null) channel = { ...channel, filter: null };
-      return [name, channel];
-    })
-  );
-}
-function maybeTip(tip2) {
-  return tip2 === true ? "xy" : tip2 === false || tip2 == null ? null : typeof tip2 === "string" ? keyword(tip2, "tip", ["x", "y", "xy"]) : tip2;
-}
-function withTip(options, pointer2) {
-  return options?.tip === true ? { ...options, tip: pointer2 } : isObject2(options?.tip) && options.tip.pointer === void 0 ? { ...options, tip: { ...options.tip, pointer: pointer2 } } : options;
-}
-
 // ../../node_modules/@observablehq/plot/src/interactions/pointer.js
 var states = /* @__PURE__ */ new WeakMap();
 function pointerK(kx2, ky2, { x: x3, y: y3, px, py, maxRadius = 40, channels, render, ...options } = {}) {
@@ -32537,7 +33041,7 @@ function inferTextChannel(scale3, data, ticks2, tickFormat2, anchor) {
   return { value: inferTickFormat(scale3, data, ticks2, tickFormat2, anchor) };
 }
 function inferTickFormat(scale3, data, ticks2, tickFormat2, anchor) {
-  return typeof tickFormat2 === "function" ? tickFormat2 : tickFormat2 === void 0 && data && isTemporal(data) ? inferTimeFormat(scale3.type, data, anchor) ?? formatDefault : scale3.tickFormat ? scale3.tickFormat(typeof ticks2 === "number" ? ticks2 : null, tickFormat2) : tickFormat2 === void 0 ? formatDefault : typeof tickFormat2 === "string" ? (isTemporal(scale3.domain()) ? utcFormat : format)(tickFormat2) : constant(tickFormat2);
+  return typeof tickFormat2 === "function" && !(scale3.type === "log" && scale3.tickFormat) ? tickFormat2 : tickFormat2 === void 0 && data && isTemporal(data) ? inferTimeFormat(scale3.type, data, anchor) ?? formatDefault : scale3.tickFormat ? scale3.tickFormat(typeof ticks2 === "number" ? ticks2 : null, tickFormat2) : tickFormat2 === void 0 ? formatDefault : typeof tickFormat2 === "string" ? (isTemporal(scale3.domain()) ? utcFormat : format)(tickFormat2) : constant(tickFormat2);
 }
 function inclusiveRange(interval2, min5, max4) {
   return interval2.range(min5, interval2.offset(interval2.floor(max4)));
@@ -32906,7 +33410,7 @@ var Tip = class extends Mark {
     for (const key in defaults5) if (key in this.channels) this[key] = defaults5[key];
     this.splitLines = splitter2(this);
     this.clipLine = clipper(this);
-    this.format = { ...format3 };
+    this.format = typeof format3 === "string" || typeof format3 === "function" ? { title: format3 } : { ...format3 };
   }
   render(index2, scales2, values2, dimensions, context) {
     const mark = this;
@@ -32925,10 +33429,10 @@ var Tip = class extends Mark {
     const ee = widthof(ellipsis);
     let sources, format3;
     if ("title" in values2) {
-      sources = values2.channels;
+      sources = getSourceChannels.call(this, { title: values2.channels.title }, scales2);
       format3 = formatTitle;
     } else {
-      sources = getSourceChannels.call(this, values2, scales2);
+      sources = getSourceChannels.call(this, values2.channels, scales2);
       format3 = formatChannels;
     }
     const g = create3("svg:g", context).call(applyIndirectStyles, this, dimensions, context).call(applyIndirectTextStyles, this).call(applyTransform, this, { x: X3 && x3, y: Y3 && y3 }).call(
@@ -33064,7 +33568,7 @@ function getPath(anchor, m, r, width, height) {
       return `M0,0l${m / 2},${-m / 2}v${m / 2 - h / 2}h${w}v${h}h${-w}v${m / 2 - h / 2}z`;
   }
 }
-function getSourceChannels({ channels }, scales2) {
+function getSourceChannels(channels, scales2) {
   const sources = {};
   let format3 = this.format;
   format3 = maybeExpandPairedFormat(format3, channels, "x");
@@ -33113,7 +33617,7 @@ function maybeExpandPairedFormat(format3, channels, key) {
   return Object.fromEntries(entries);
 }
 function formatTitle(i, index2, { title }) {
-  return formatDefault(title.value[i], i);
+  return this.format.title(title.value[i], i);
 }
 function* formatChannels(i, index2, channels, scales2, values2) {
   for (const key in channels) {
@@ -33364,6 +33868,7 @@ function plot(options = {}) {
     if (subtitle != null) figure.append(createTitleElement(document2, subtitle, "h3"));
     figure.append(...legends, svg);
     if (caption != null) figure.append(createFigcaption(document2, caption));
+    if ("value" in svg) figure.value = svg.value, delete svg.value;
   }
   figure.scale = exposeScales(scales2.scales);
   figure.legend = exposeLegends(scaleDescriptors, context, options);
@@ -33384,10 +33889,6 @@ function createFigcaption(document2, caption) {
   e.append(caption);
   return e;
 }
-function plotThis({ marks: marks2 = [], ...options } = {}) {
-  return plot({ ...options, marks: [...marks2, this] });
-}
-Mark.prototype.plot = plotThis;
 function flatMarks(marks2) {
   return marks2.flat(Infinity).filter((mark) => mark != null).map(markify);
 }
@@ -33414,7 +33915,7 @@ function applyScaleTransform(channel, options) {
     type: type2,
     percent,
     interval: interval2,
-    transform: transform3 = percent ? (x3) => x3 * 100 : maybeIntervalTransform(interval2, type2)
+    transform: transform3 = percent ? (x3) => x3 == null ? NaN : x3 * 100 : maybeIntervalTransform(interval2, type2)
   } = options[scale3] ?? {};
   if (transform3 == null) return;
   channel.value = map2(channel.value, transform3);
@@ -33973,7 +34474,7 @@ function maybeThresholds(thresholds, interval2, defaultThresholds = thresholdAut
       case "auto":
         return thresholdAuto;
     }
-    return maybeUtcInterval(thresholds);
+    return utcInterval(thresholds);
   }
   return thresholds;
 }
@@ -36128,14 +36629,15 @@ function interpolatorBarycentric({ random = lcg(42) } = {}) {
           if (x3 < 0 || x3 >= width || y3 < 0 || y3 >= height) continue;
           const xp = x3 + 0.5;
           const yp = y3 + 0.5;
-          const ga = ((By - Cy) * (xp - Cx) + (yp - Cy) * (Cx - Bx)) / z;
-          if (ga < 0) continue;
-          const gb = ((Cy - Ay) * (xp - Cx) + (yp - Cy) * (Ax - Cx)) / z;
-          if (gb < 0) continue;
-          const gc = 1 - ga - gb;
-          if (gc < 0) continue;
+          const s2 = Math.sign(z);
+          const ga = (By - Cy) * (xp - Cx) + (yp - Cy) * (Cx - Bx);
+          if (ga * s2 < 0) continue;
+          const gb = (Cy - Ay) * (xp - Cx) + (yp - Cy) * (Ax - Cx);
+          if (gb * s2 < 0) continue;
+          const gc = z - (ga + gb);
+          if (gc * s2 < 0) continue;
           const i2 = x3 + width * y3;
-          W[i2] = mix(va, ga, vb, gb, vc, gc, x3, y3);
+          W[i2] = mix(va, ga / z, vb, gb / z, vc, gc / z, x3, y3);
           S[i2] = 1;
         }
       }
@@ -37934,7 +38436,7 @@ function dodge(y3, x3, anchor, padding, r, options) {
     for (let I of facets) {
       const tree2 = (0, import_interval_tree_1d.default)();
       I = I.filter(R ? (i) => finite2(X3[i]) && positive(R[i]) : (i) => finite2(X3[i]));
-      const intervals = new Float64Array(2 * I.length + 2);
+      const intervals2 = new Float64Array(2 * I.length + 2);
       for (const i of I) {
         const ri = radius2(i);
         const y06 = ky2 ? ri + padding : 0;
@@ -37946,14 +38448,14 @@ function dodge(y3, x3, anchor, padding, r, options) {
           const dx = X3[i] - X3[j];
           const dr = padding + (R ? R[i] + R[j] : 2 * cr);
           const dy = Math.sqrt(dr * dr - dx * dx);
-          intervals[k2++] = yj - dy;
-          intervals[k2++] = yj + dy;
+          intervals2[k2++] = yj - dy;
+          intervals2[k2++] = yj + dy;
         });
-        let candidates = intervals.slice(0, k2);
+        let candidates = intervals2.slice(0, k2);
         if (ky2) candidates = candidates.filter((y4) => y4 >= 0);
         out: for (const y4 of candidates.sort(compare)) {
           for (let j = 0; j < k2; j += 2) {
-            if (intervals[j] + 1e-6 < y4 && y4 < intervals[j + 1] - 1e-6) {
+            if (intervals2[j] + 1e-6 < y4 && y4 < intervals2[j + 1] - 1e-6) {
               continue out;
             }
           }
@@ -38194,6 +38696,11 @@ function selectChannel(v2, selector, options) {
   });
 }
 
+// ../../node_modules/@observablehq/plot/src/index.js
+Mark.prototype.plot = function({ marks: marks2 = [], ...options } = {}) {
+  return plot({ ...options, marks: [...marks2, this] });
+};
+
 // src/plot-attributes.js
 var attributeMap = /* @__PURE__ */ new Map([
   ["style", "style"],
@@ -38379,6 +38886,7 @@ var attributeMap = /* @__PURE__ */ new Map([
   ["rRange", "r.range"],
   ["rClamp", "r.clamp"],
   ["rNice", "r.nice"],
+  ["rLabel", "r.label"],
   ["rPercent", "r.percent"],
   ["rZero", "r.zero"],
   ["rBase", "r.base"],
@@ -38438,39 +38946,35 @@ var OPTIONS_ONLY_MARKS = /* @__PURE__ */ new Set([
   "sphere",
   "graticule"
 ]);
+var SELECT_TRANSFORMS = /* @__PURE__ */ new Map([
+  ["first", selectFirst],
+  ["last", selectLast],
+  ["maxX", selectMaxX],
+  ["maxY", selectMaxY],
+  ["minX", selectMinX],
+  ["minY", selectMinY],
+  ["nearest", pointer],
+  ["nearestX", pointerX],
+  ["nearestXY", pointerY]
+]);
 async function plotRenderer(plot2) {
   const spec = { marks: [] };
   const symbols3 = [];
   const { attributes, marks: marks2 } = plot2;
   setAttributes(attributes, spec, symbols3);
-  const indices = [];
+  const indices2 = [];
   for (const mark of marks2) {
     for (const { type: type2, data, options } of mark.plotSpecs()) {
-      if (OPTIONS_ONLY_MARKS.has(type2)) {
-        spec.marks.push(src_exports[type2](options));
-      } else if (isArrowTable(data)) {
-        const opts = Object.fromEntries(
-          Object.entries(options).map(([k2, v2]) => {
-            let val = v2;
-            if (typeof v2 === "string") {
-              val = data.getChild(v2) ?? v2;
-            } else if (typeof v2 === "object") {
-              const value = data.getChild(v2.value);
-              val = value ? { value } : v2;
-            }
-            return [k2, val];
-          })
-        );
-        spec.marks.push(src_exports[type2]({ length: data.numRows }, opts));
-      } else {
-        spec.marks.push(src_exports[type2](data, options));
-      }
-      indices.push(mark.index);
+      const { select: select2, ...rest } = options;
+      const opt = SELECT_TRANSFORMS.get(select2)?.(rest) ?? rest;
+      const arg = OPTIONS_ONLY_MARKS.has(type2) ? [opt] : [data, opt];
+      spec.marks.push(src_exports[type2](...arg));
+      indices2.push(mark.index);
     }
   }
   inferLabels(spec, plot2);
   const svg = plot(spec);
-  annotatePlot(svg, indices);
+  annotatePlot(svg, indices2);
   setSymbolAttributes(plot2, svg, attributes, symbols3);
   for (const interactor of plot2.interactors) {
     await interactor.init(svg);
@@ -38536,27 +39040,28 @@ function inferLabel(key, spec, marks2) {
   }
   spec[key] = { ...scale3, label: candidate };
 }
-function annotatePlot(svg, indices) {
+function annotatePlot(svg, indices2) {
   const facets = svg.querySelectorAll('g[aria-label="facet"]');
   if (facets.length) {
     for (const facet of facets) {
-      annotateMarks(facet, indices);
+      annotateMarks(facet, indices2);
     }
   } else {
-    annotateMarks(svg, indices);
+    annotateMarks(svg, indices2);
   }
 }
-function annotateMarks(svg, indices) {
+function annotateMarks(svg, indices2) {
   let index2 = -1;
   for (const child of svg.children) {
     const aria = child.getAttribute("aria-label") || "";
     const skip = child.nodeName === "style" || aria.includes("-axis") || aria.includes("-grid");
     if (!skip) {
-      child.setAttribute("data-index", indices[++index2]);
+      child.setAttribute("data-index", indices2[++index2]);
     }
   }
 }
 function getType(data, channel) {
+  if (!data) return;
   const { columns } = data;
   const col = columns[channel] ?? columns[channel + "1"] ?? columns[channel + "2"];
   if (col) {
@@ -38606,8 +39111,8 @@ var Plot = class {
   innerHeight(defaultValue = 400) {
     const { top: top2, bottom: bottom2 } = this.margins();
     let h = this.getAttribute("height");
-    if (h == null && defaultValue != null) {
-      h = defaultValue;
+    if (h == null) {
+      h = maybeAspectRatio(this, top2, bottom2) || defaultValue;
       this.setAttribute("height", h, { silent: true });
     }
     return h - top2 - bottom2;
@@ -38711,6 +39216,16 @@ var Plot = class {
     this.legends.push({ legend: legend2, include });
   }
 };
+function maybeAspectRatio(plot2, top2, bottom2) {
+  const ar = plot2.getAttribute("aspectRatio");
+  if (ar == null) return;
+  const x3 = plot2.getAttribute("xDomain");
+  const y3 = plot2.getAttribute("yDomain");
+  if (!x3 || !y3) return;
+  const dx = Math.abs(x3[1] - x3[0]);
+  const dy = Math.abs(y3[1] - y3[0]);
+  return dy * plot2.innerWidth() / (ar * dx) + top2 + bottom2;
+}
 
 // src/marks/util/is-color.js
 function isColor2(value) {
@@ -38757,7 +39272,8 @@ var constantOptions = /* @__PURE__ */ new Set([
   "crossOrigin",
   "paintOrder",
   "pointerEvents",
-  "target"
+  "target",
+  "select"
 ]);
 function isConstantOption(value) {
   return constantOptions.has(value);
@@ -38784,39 +39300,6 @@ function isSymbol2(value) {
   return symbols2.has(`${value}`.toLowerCase());
 }
 
-// src/marks/util/to-data-columns.js
-function toDataColumns(data) {
-  return isArrowTable(data) ? arrowToColumns(data) : arrayToColumns(data);
-}
-function arrowToColumns(data) {
-  const { numRows, numCols, schema: { fields } } = data;
-  const columns = {};
-  for (let col = 0; col < numCols; ++col) {
-    const name = fields[col].name;
-    if (columns[name]) {
-      console.warn(`Redundant column name "${name}". Skipping...`);
-    } else {
-      columns[name] = convertArrowColumn(data.getChildAt(col));
-    }
-  }
-  return { numRows, columns };
-}
-function arrayToColumns(data) {
-  const numRows = data.length;
-  if (typeof data[0] === "object") {
-    const names = numRows ? Object.keys(data[0]) : [];
-    const columns = {};
-    if (names.length > 0) {
-      names.forEach((name) => {
-        columns[name] = data.map((d) => d[name]);
-      });
-    }
-    return { numRows, columns };
-  } else {
-    return { numRows, values: data };
-  }
-}
-
 // src/marks/Mark.js
 var isColorChannel = (channel) => channel === "stroke" || channel === "fill";
 var isOpacityChannel = (channel) => /opacity$/i.test(channel);
@@ -38885,7 +39368,7 @@ var Mark2 = class extends MosaicClient {
   }
   /**
    * @param {import('../plot.js').Plot} plot The plot.
-   * @param {number} index 
+   * @param {number} index
    */
   setPlot(plot2, index2) {
     this.plot = plot2;
@@ -38960,18 +39443,8 @@ var Mark2 = class extends MosaicClient {
    * @returns {object[]}
    */
   plotSpecs() {
-    const { type: type2, detail, channels } = this;
-    const { numRows: length4, values: values2, columns } = this.data || {};
-    const options = {};
-    const side = {};
-    for (const c4 of channels) {
-      const obj = detail.has(c4.channel) ? side : options;
-      obj[c4.channel] = channelOption(c4, columns);
-    }
-    if (detail.size) options.channels = side;
-    const data = values2 ?? (this.data ? { length: length4 } : null);
-    const spec = [{ type: type2, data, options }];
-    return spec;
+    const { type: type2, data, detail, channels } = this;
+    return markPlotSpec(type2, detail, channels, data);
   }
 };
 function channelOption(c4, columns) {
@@ -39002,6 +39475,18 @@ function markQuery(channels, table, skip = []) {
   }
   return q;
 }
+function markPlotSpec(type2, detail, channels, data, options = {}) {
+  const { numRows: length4, values: values2, columns } = data ?? {};
+  const side = {};
+  for (const c4 of channels) {
+    const obj = detail.has(c4.channel) ? side : options;
+    obj[c4.channel] = channelOption(c4, columns);
+  }
+  if (detail.size) options.channels = side;
+  const specData = values2 ?? (data ? { length: length4 } : null);
+  const spec = [{ type: type2, data: specData, options }];
+  return spec;
+}
 
 // src/marks/util/channel-scale.js
 function channelScale(mark, channel) {
@@ -39428,7 +39913,7 @@ var Grid2DMark = class extends Mark2 {
   }
   /**
    * @param {import('../plot.js').Plot} plot The plot.
-   * @param {number} index 
+   * @param {number} index
    */
   setPlot(plot2, index2) {
     const update2 = () => {
@@ -39676,6 +40161,17 @@ function transform2(geometry, x3, y3) {
   return geometry;
 }
 
+// src/marks/util/permute.js
+function indices(length4) {
+  return Array.from({ length: length4 }, (_, i) => i);
+}
+function permute2(data, order) {
+  const ord = order.reduce((acc, val, i) => (acc[val] = i, acc), {});
+  const idx = indices(data.length);
+  idx.sort((a2, b) => ord[data[a2]] - ord[data[b]]);
+  return idx;
+}
+
 // src/marks/util/raster.js
 function createCanvas(w, h) {
   if (typeof document !== "undefined") {
@@ -39810,12 +40306,13 @@ var RasterMark = class extends Grid2DMark {
     const { alpha, alphaProp, color: color3, colorProp } = rasterEncoding(this);
     const alphaData = columns[alphaProp] ?? [];
     const colorData = columns[colorProp] ?? [];
+    const idx = numRows > 1 && colorProp && this.groupby?.includes(colorProp) ? permute2(colorData, this.plot.getAttribute("colorDomain")) : indices(numRows);
     this.data = {
       numRows,
       columns: {
         src: Array.from({ length: numRows }, (_, i) => {
-          color3?.(img.data, w, h, colorData[i]);
-          alpha?.(img.data, w, h, alphaData[i]);
+          color3?.(img.data, w, h, colorData[idx[i]]);
+          alpha?.(img.data, w, h, alphaData[idx[i]]);
           ctx.putImageData(img, 0, 0);
           return canvas.toDataURL();
         })
@@ -39902,7 +40399,7 @@ function colorScale(mark, prop) {
   const domainAttr = plot2.getAttribute("colorDomain");
   const domainFixed = domainAttr === Fixed;
   const domainTransient = domainAttr?.[Transient];
-  const domain = !domainFixed && !domainTransient && domainAttr || (flat ? data.sort(ascending) : discrete ? gridDomainDiscrete(data) : gridDomainContinuous(data));
+  const domain = !domainFixed && !domainTransient && domainAttr || (flat ? data.slice().sort(ascending) : discrete ? gridDomainDiscrete(data) : gridDomainContinuous(data));
   if (domainFixed || domainTransient || !domainAttr) {
     if (!domainFixed) domain[Transient] = true;
     plot2.setAttribute("colorDomain", domain);
@@ -40025,7 +40522,7 @@ function lineDensity(q, x3, y3, z, xn, yn, groupby = [], normalize4 = true) {
     sql`(y0 > 0 OR y0 + dy > 0)`
   ));
   const num = Query.select({ x: sql`GREATEST(MAX(ABS(dx)), MAX(ABS(dy)))` }).from("pairs");
-  const indices = Query.select({ i: sql`UNNEST(range((${num})))::INTEGER` });
+  const indices2 = Query.select({ i: sql`UNNEST(range((${num})))::INTEGER` });
   const raster2 = Query.unionAll(
     Query.select(groups2, {
       x: sql`x0 + i`,
@@ -40044,7 +40541,7 @@ function lineDensity(q, x3, y3, z, xn, yn, groupby = [], normalize4 = true) {
     "y",
     normalize4 ? { w: sql`1.0 / COUNT(*) OVER (PARTITION BY ${pointPart})` } : null
   ).where(and(isBetween("x", [0, xn], true), isBetween("y", [0, yn], true)));
-  return Query.with({ pairs: pairs2, indices, raster: raster2, points: points2 }).from("points").select(groupby, {
+  return Query.with({ pairs: pairs2, indices: indices2, raster: raster2, points: points2 }).from("points").select(groupby, {
     index: sql`x + y * ${xn}::INTEGER`,
     density: normalize4 ? sum("w") : count()
   }).groupby("index", groupby);
@@ -40209,6 +40706,220 @@ function points(data, bins2, x06, y06, deltaX, deltaY, invertX, invertY, offset2
   return { numRows, columns };
 }
 
+// src/marks/util/stats.js
+function ibetainv2(p, a2, b) {
+  var EPS2 = 1e-8;
+  var a1 = a2 - 1;
+  var b1 = b - 1;
+  var j = 0;
+  var lna, lnb, pp, t, u4, err, x3, al, h, w, afac;
+  if (p <= 0) return 0;
+  if (p >= 1) return 1;
+  if (a2 >= 1 && b >= 1) {
+    pp = p < 0.5 ? p : 1 - p;
+    t = Math.sqrt(-2 * Math.log(pp));
+    x3 = (2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t;
+    if (p < 0.5) x3 = -x3;
+    al = (x3 * x3 - 3) / 6;
+    h = 2 / (1 / (2 * a2 - 1) + 1 / (2 * b - 1));
+    w = x3 * Math.sqrt(al + h) / h - (1 / (2 * b - 1) - 1 / (2 * a2 - 1)) * (al + 5 / 6 - 2 / (3 * h));
+    x3 = a2 / (a2 + b * Math.exp(2 * w));
+  } else {
+    lna = Math.log(a2 / (a2 + b));
+    lnb = Math.log(b / (a2 + b));
+    t = Math.exp(a2 * lna) / a2;
+    u4 = Math.exp(b * lnb) / b;
+    w = t + u4;
+    if (p < t / w) x3 = Math.pow(a2 * w * p, 1 / a2);
+    else x3 = 1 - Math.pow(b * w * (1 - p), 1 / b);
+  }
+  afac = -gammaln2(a2) - gammaln2(b) + gammaln2(a2 + b);
+  for (; j < 10; j++) {
+    if (x3 === 0 || x3 === 1) return x3;
+    err = ibeta2(x3, a2, b) - p;
+    t = Math.exp(a1 * Math.log(x3) + b1 * Math.log(1 - x3) + afac);
+    u4 = err / t;
+    x3 -= t = u4 / (1 - 0.5 * Math.min(1, u4 * (a1 / x3 - b1 / (1 - x3))));
+    if (x3 <= 0) x3 = 0.5 * (x3 + t);
+    if (x3 >= 1) x3 = 0.5 * (x3 + t + 1);
+    if (Math.abs(t) < EPS2 * x3 && j > 0) break;
+  }
+  return x3;
+}
+function ibeta2(x3, a2, b) {
+  var bt = x3 === 0 || x3 === 1 ? 0 : Math.exp(gammaln2(a2 + b) - gammaln2(a2) - gammaln2(b) + a2 * Math.log(x3) + b * Math.log(1 - x3));
+  if (x3 < 0 || x3 > 1) return 0;
+  if (x3 < (a2 + 1) / (a2 + b + 2))
+    return bt * betacf2(x3, a2, b) / a2;
+  return 1 - bt * betacf2(1 - x3, b, a2) / b;
+}
+function betacf2(x3, a2, b) {
+  var fpmin = 1e-30;
+  var m = 1;
+  var qab = a2 + b;
+  var qap = a2 + 1;
+  var qam = a2 - 1;
+  var c4 = 1;
+  var d = 1 - qab * x3 / qap;
+  var m2, aa2, del, h;
+  if (Math.abs(d) < fpmin) d = fpmin;
+  d = 1 / d;
+  h = d;
+  for (; m <= 100; m++) {
+    m2 = 2 * m;
+    aa2 = m * (b - m) * x3 / ((qam + m2) * (a2 + m2));
+    d = 1 + aa2 * d;
+    if (Math.abs(d) < fpmin) d = fpmin;
+    c4 = 1 + aa2 / c4;
+    if (Math.abs(c4) < fpmin) c4 = fpmin;
+    d = 1 / d;
+    h *= d * c4;
+    aa2 = -(a2 + m) * (qab + m) * x3 / ((a2 + m2) * (qap + m2));
+    d = 1 + aa2 * d;
+    if (Math.abs(d) < fpmin) d = fpmin;
+    c4 = 1 + aa2 / c4;
+    if (Math.abs(c4) < fpmin) c4 = fpmin;
+    d = 1 / d;
+    del = d * c4;
+    h *= del;
+    if (Math.abs(del - 1) < 3e-7) break;
+  }
+  return h;
+}
+function gammaln2(x3) {
+  var j = 0;
+  var cof = [
+    76.18009172947146,
+    -86.5053203294167,
+    24.01409824083091,
+    -1.231739572450155,
+    0.001208650973866179,
+    -5395239384953e-18
+  ];
+  var ser = 1.000000000190015;
+  var xx, y3, tmp2;
+  tmp2 = (y3 = xx = x3) + 5.5;
+  tmp2 -= (xx + 0.5) * Math.log(tmp2);
+  for (; j < 6; j++) ser += cof[j] / ++y3;
+  return Math.log(2.506628274631 * ser / xx) - tmp2;
+}
+function qt2(p, dof) {
+  var x3 = ibetainv2(2 * Math.min(p, 1 - p), 0.5 * dof, 0.5);
+  x3 = Math.sqrt(dof * (1 - x3) / x3);
+  return p > 0.5 ? x3 : -x3;
+}
+function erfinv(x3) {
+  let w = -Math.log((1 - x3) * (1 + x3));
+  let p;
+  if (w < 6.25) {
+    w -= 3.125;
+    p = -364441206401782e-35;
+    p = -16850591381820166e-35 + p * w;
+    p = 128584807152564e-32 + p * w;
+    p = 11157877678025181e-33 + p * w;
+    p = -1333171662854621e-31 + p * w;
+    p = 20972767875968562e-33 + p * w;
+    p = 6637638134358324e-30 + p * w;
+    p = -4054566272975207e-29 + p * w;
+    p = -8151934197605472e-29 + p * w;
+    p = 26335093153082323e-28 + p * w;
+    p = -12975133253453532e-27 + p * w;
+    p = -5415412054294628e-26 + p * w;
+    p = 10512122733215323e-25 + p * w;
+    p = -4112633980346984e-24 + p * w;
+    p = -29070369957882005e-24 + p * w;
+    p = 42347877827932404e-23 + p * w;
+    p = -13654692000834679e-22 + p * w;
+    p = -13882523362786469e-21 + p * w;
+    p = 18673420803405714e-20 + p * w;
+    p = -740702534166267e-18 + p * w;
+    p = -0.006033670871430149 + p * w;
+    p = 0.24015818242558962 + p * w;
+    p = 1.6536545626831027 + p * w;
+  } else if (w < 16) {
+    w = Math.sqrt(w) - 3.25;
+    p = 22137376921775787e-25;
+    p = 9075656193888539e-23 + p * w;
+    p = -27517406297064545e-23 + p * w;
+    p = 18239629214389228e-24 + p * w;
+    p = 15027403968909828e-22 + p * w;
+    p = -4013867526981546e-21 + p * w;
+    p = 29234449089955446e-22 + p * w;
+    p = 12475304481671779e-21 + p * w;
+    p = -47318229009055734e-21 + p * w;
+    p = 6828485145957318e-20 + p * w;
+    p = 24031110387097894e-21 + p * w;
+    p = -3550375203628475e-19 + p * w;
+    p = 9532893797373805e-19 + p * w;
+    p = -0.0016882755560235047 + p * w;
+    p = 0.002491442096107851 + p * w;
+    p = -0.003751208507569241 + p * w;
+    p = 0.005370914553590064 + p * w;
+    p = 1.0052589676941592 + p * w;
+    p = 3.0838856104922208 + p * w;
+  } else if (Number.isFinite(w)) {
+    w = Math.sqrt(w) - 5;
+    p = -27109920616438573e-27;
+    p = -2555641816996525e-25 + p * w;
+    p = 15076572693500548e-25 + p * w;
+    p = -3789465440126737e-24 + p * w;
+    p = 761570120807834e-23 + p * w;
+    p = -1496002662714924e-23 + p * w;
+    p = 2914795345090108e-23 + p * w;
+    p = -6771199775845234e-23 + p * w;
+    p = 22900482228026655e-23 + p * w;
+    p = -99298272942317e-20 + p * w;
+    p = 4526062597223154e-21 + p * w;
+    p = -1968177810553167e-20 + p * w;
+    p = 7599527703001776e-20 + p * w;
+    p = -21503011930044477e-20 + p * w;
+    p = -13871931833623122e-20 + p * w;
+    p = 1.0103004648645344 + p * w;
+    p = 4.849906401408584 + p * w;
+  } else {
+    p = Infinity;
+  }
+  return p * x3;
+}
+
+// src/marks/ErrorBarMark.js
+var ErrorBarMark = class extends Mark2 {
+  constructor(type2, source, options) {
+    const dim = type2.endsWith("X") ? "y" : "x";
+    const { ci = 0.95, ...channels } = options;
+    super(type2, source, channels);
+    this.dim = dim;
+    this.field = this.channelField(dim).field;
+    this.channels = this.channels.filter((c4) => c4.channel !== dim);
+    this.ci = handleParam(ci, (value) => {
+      return this.ci = value, this.update();
+    });
+  }
+  query(filter3 = []) {
+    const { channels, field: field2, source: { table } } = this;
+    const fields = channels.concat([
+      { field: avg(field2), as: "__avg__" },
+      { field: count(field2), as: "__n__" },
+      { field: stddev(field2), as: "__sd__" }
+    ]);
+    return markQuery(fields, table).where(filter3);
+  }
+  queryResult(data) {
+    this.data = toDataColumns(data);
+    return this;
+  }
+  plotSpecs() {
+    const { type: type2, dim, detail, data, ci, channels } = this;
+    const p = Math.SQRT2 * erfinv(ci);
+    const { columns: { __avg__: u4, __sd__: s2, __n__: n } } = data;
+    const options = {
+      [`${dim}1`]: u4.map((u5, i) => u5 - p * s2[i] / Math.sqrt(n[i])),
+      [`${dim}2`]: u4.map((u5, i) => u5 + p * s2[i] / Math.sqrt(n[i]))
+    };
+    return markPlotSpec(type2, detail, channels, data, options);
+  }
+};
+
 // src/marks/GeoMark.js
 var DEFAULT_GEOMETRY_COLUMN = "geom";
 var GeoMark = class extends Mark2 {
@@ -40248,50 +40959,48 @@ var HexbinMark = class extends Mark2 {
   query(filter3 = []) {
     if (this.hasOwnData()) return null;
     const { plot: plot2, binWidth, channels, source } = this;
-    const [x12, x22] = extentX(this, filter3);
-    const [y12, y22] = extentY(this, filter3);
-    const ox2 = 0.5 - plot2.getAttribute("marginLeft");
-    const oy2 = 0 - plot2.getAttribute("marginTop");
-    const dx = `${binWidth}::DOUBLE`;
-    const dy = `${binWidth * (1.5 / Math.sqrt(3))}::DOUBLE`;
-    const xr = `${plot2.innerWidth() / (x22 - x12)}::DOUBLE`;
-    const yr = `${plot2.innerHeight() / (y22 - y12)}::DOUBLE`;
     let x3, y3;
-    const aggr = /* @__PURE__ */ new Set();
+    const dims = /* @__PURE__ */ new Set();
     const cols = {};
-    let orderby;
     for (const c4 of channels) {
       if (c4.channel === "orderby") {
-        orderby = c4.value;
       } else if (c4.channel === "x") {
         x3 = c4;
       } else if (c4.channel === "y") {
         y3 = c4;
       } else if (Object.hasOwn(c4, "field")) {
-        cols[c4.as] = c4.field;
-        if (c4.field.aggregate) {
-          c4.field.columns.forEach((col) => aggr.add(col));
+        const { as, field: field2 } = c4;
+        cols[as] = field2;
+        if (!field2.aggregate) {
+          dims.add(as);
         }
       }
     }
-    const q = Query.select({
-      [x3.as]: sql`${x12}::DOUBLE + ((x + 0.5 * (y & 1)) * ${dx} + ${ox2})::DOUBLE / ${xr}`,
-      [y3.as]: sql`${y22}::DOUBLE - (y * ${dy} + ${oy2})::DOUBLE / ${yr}`,
+    const [x12, x22] = extentX(this, filter3);
+    const [y12, y22] = extentY(this, filter3);
+    const ox2 = 0.5 - plot2.getAttribute("marginLeft");
+    const oy2 = 0 - plot2.getAttribute("marginTop");
+    const dx = `${binWidth}::DOUBLE`;
+    const dy = `${binWidth * (1.5 / Math.sqrt(3))}::DOUBLE`;
+    const xr = `${plot2.innerWidth() / (x22 - x12)}::DOUBLE`;
+    const yr = `${plot2.innerHeight() / (y22 - y12)}::DOUBLE`;
+    return Query.select({
+      [x3.as]: sql`${x12}::DOUBLE + ((_x + 0.5 * (_y & 1)) * ${dx} + ${ox2})::DOUBLE / ${xr}`,
+      [y3.as]: sql`${y22}::DOUBLE - (_y * ${dy} + ${oy2})::DOUBLE / ${yr}`,
       ...cols
-    }).groupby("x", "y");
-    if (orderby) q.orderby(orderby);
-    const xx = `${xr} * (${x3.field} - ${x12}::DOUBLE)`;
-    const yy = `${yr} * (${y22}::DOUBLE - ${y3.field})`;
-    const hex2 = Query.select({
-      py: sql`(${yy} - ${oy2}) / ${dy}`,
-      pj: sql`ROUND(py)::INTEGER`,
-      px: sql`(${xx} - ${ox2}) / ${dx} - 0.5 * (pj & 1)`,
-      pi: sql`ROUND(px)::INTEGER`,
-      tt: sql`ABS(py-pj) * 3 > 1 AND (px-pi)**2 + (py-pj)**2 > (px - pi - 0.5 * CASE WHEN px < pi THEN -1 ELSE 1 END)**2 + (py - pj - CASE WHEN py < pj THEN -1 ELSE 1 END)**2`,
-      x: sql`CASE WHEN tt THEN (pi + (CASE WHEN px < pi THEN -0.5 ELSE 0.5 END) + (CASE WHEN pj & 1 <> 0 THEN 0.5 ELSE -0.5 END))::INTEGER ELSE pi END`,
-      y: sql`CASE WHEN tt THEN (pj + CASE WHEN py < pj THEN -1 ELSE 1 END)::INTEGER ELSE pj END`
-    }).select(Array.from(aggr)).from(source.table).where(isNotNull(x3.field), isNotNull(y3.field), filter3);
-    return q.from(hex2);
+    }).groupby("_x", "_y", ...dims).from(
+      // Subquery performs hex binning in screen space and also passes
+      // original columns through (the DB should optimize this).
+      Query.select({
+        _py: sql`(${yr} * (${y22}::DOUBLE - ${y3.field}) - ${oy2}) / ${dy}`,
+        _pj: sql`ROUND(_py)::INTEGER`,
+        _px: sql`(${xr} * (${x3.field} - ${x12}::DOUBLE) - ${ox2}) / ${dx} - 0.5 * (_pj & 1)`,
+        _pi: sql`ROUND(_px)::INTEGER`,
+        _tt: sql`ABS(_py-_pj) * 3 > 1 AND (_px-_pi)**2 + (_py-_pj)**2 > (_px - _pi - 0.5 * CASE WHEN _px < _pi THEN -1 ELSE 1 END)**2 + (_py - _pj - CASE WHEN _py < _pj THEN -1 ELSE 1 END)**2`,
+        _x: sql`CASE WHEN _tt THEN (_pi + (CASE WHEN _px < _pi THEN -0.5 ELSE 0.5 END) + (CASE WHEN _pj & 1 <> 0 THEN 0.5 ELSE -0.5 END))::INTEGER ELSE _pi END`,
+        _y: sql`CASE WHEN _tt THEN (_pj + CASE WHEN _py < _pj THEN -1 ELSE 1 END)::INTEGER ELSE _pj END`
+      }, "*").from(source.table).where(isNotNull(x3.field), isNotNull(y3.field), filter3)
+    );
   }
 };
 
@@ -40428,12 +41137,13 @@ var RasterTileMark = class extends Grid2DMark {
     const { alpha, alphaProp, color: color3, colorProp } = rasterEncoding(this);
     const alphaData = columns[alphaProp] ?? [];
     const colorData = columns[colorProp] ?? [];
+    const idx = numRows > 1 && colorProp && this.groupby?.includes(colorProp) ? permute2(colorData, this.plot.getAttribute("colorDomain")) : indices(numRows);
     this.data = {
       numRows,
       columns: {
         src: Array.from({ length: numRows }, (_, i) => {
-          color3?.(img.data, w, h, colorData[i]);
-          alpha?.(img.data, w, h, alphaData[i]);
+          color3?.(img.data, w, h, colorData[idx[i]]);
+          alpha?.(img.data, w, h, alphaData[idx[i]]);
           ctx.putImageData(img, 0, 0);
           return canvas.toDataURL();
         })
@@ -40519,109 +41229,6 @@ function tileFloor(value) {
   return floored === value ? floored - 1 : floored;
 }
 
-// src/marks/util/stats.js
-function ibetainv2(p, a2, b) {
-  var EPS2 = 1e-8;
-  var a1 = a2 - 1;
-  var b1 = b - 1;
-  var j = 0;
-  var lna, lnb, pp, t, u4, err, x3, al, h, w, afac;
-  if (p <= 0) return 0;
-  if (p >= 1) return 1;
-  if (a2 >= 1 && b >= 1) {
-    pp = p < 0.5 ? p : 1 - p;
-    t = Math.sqrt(-2 * Math.log(pp));
-    x3 = (2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t;
-    if (p < 0.5) x3 = -x3;
-    al = (x3 * x3 - 3) / 6;
-    h = 2 / (1 / (2 * a2 - 1) + 1 / (2 * b - 1));
-    w = x3 * Math.sqrt(al + h) / h - (1 / (2 * b - 1) - 1 / (2 * a2 - 1)) * (al + 5 / 6 - 2 / (3 * h));
-    x3 = a2 / (a2 + b * Math.exp(2 * w));
-  } else {
-    lna = Math.log(a2 / (a2 + b));
-    lnb = Math.log(b / (a2 + b));
-    t = Math.exp(a2 * lna) / a2;
-    u4 = Math.exp(b * lnb) / b;
-    w = t + u4;
-    if (p < t / w) x3 = Math.pow(a2 * w * p, 1 / a2);
-    else x3 = 1 - Math.pow(b * w * (1 - p), 1 / b);
-  }
-  afac = -gammaln2(a2) - gammaln2(b) + gammaln2(a2 + b);
-  for (; j < 10; j++) {
-    if (x3 === 0 || x3 === 1) return x3;
-    err = ibeta2(x3, a2, b) - p;
-    t = Math.exp(a1 * Math.log(x3) + b1 * Math.log(1 - x3) + afac);
-    u4 = err / t;
-    x3 -= t = u4 / (1 - 0.5 * Math.min(1, u4 * (a1 / x3 - b1 / (1 - x3))));
-    if (x3 <= 0) x3 = 0.5 * (x3 + t);
-    if (x3 >= 1) x3 = 0.5 * (x3 + t + 1);
-    if (Math.abs(t) < EPS2 * x3 && j > 0) break;
-  }
-  return x3;
-}
-function ibeta2(x3, a2, b) {
-  var bt = x3 === 0 || x3 === 1 ? 0 : Math.exp(gammaln2(a2 + b) - gammaln2(a2) - gammaln2(b) + a2 * Math.log(x3) + b * Math.log(1 - x3));
-  if (x3 < 0 || x3 > 1) return 0;
-  if (x3 < (a2 + 1) / (a2 + b + 2))
-    return bt * betacf2(x3, a2, b) / a2;
-  return 1 - bt * betacf2(1 - x3, b, a2) / b;
-}
-function betacf2(x3, a2, b) {
-  var fpmin = 1e-30;
-  var m = 1;
-  var qab = a2 + b;
-  var qap = a2 + 1;
-  var qam = a2 - 1;
-  var c4 = 1;
-  var d = 1 - qab * x3 / qap;
-  var m2, aa2, del, h;
-  if (Math.abs(d) < fpmin) d = fpmin;
-  d = 1 / d;
-  h = d;
-  for (; m <= 100; m++) {
-    m2 = 2 * m;
-    aa2 = m * (b - m) * x3 / ((qam + m2) * (a2 + m2));
-    d = 1 + aa2 * d;
-    if (Math.abs(d) < fpmin) d = fpmin;
-    c4 = 1 + aa2 / c4;
-    if (Math.abs(c4) < fpmin) c4 = fpmin;
-    d = 1 / d;
-    h *= d * c4;
-    aa2 = -(a2 + m) * (qab + m) * x3 / ((a2 + m2) * (qap + m2));
-    d = 1 + aa2 * d;
-    if (Math.abs(d) < fpmin) d = fpmin;
-    c4 = 1 + aa2 / c4;
-    if (Math.abs(c4) < fpmin) c4 = fpmin;
-    d = 1 / d;
-    del = d * c4;
-    h *= del;
-    if (Math.abs(del - 1) < 3e-7) break;
-  }
-  return h;
-}
-function gammaln2(x3) {
-  var j = 0;
-  var cof = [
-    76.18009172947146,
-    -86.5053203294167,
-    24.01409824083091,
-    -1.231739572450155,
-    0.001208650973866179,
-    -5395239384953e-18
-  ];
-  var ser = 1.000000000190015;
-  var xx, y3, tmp2;
-  tmp2 = (y3 = xx = x3) + 5.5;
-  tmp2 -= (xx + 0.5) * Math.log(tmp2);
-  for (; j < 6; j++) ser += cof[j] / ++y3;
-  return Math.log(2.506628274631 * ser / xx) - tmp2;
-}
-function qt2(p, dof) {
-  var x3 = ibetainv2(2 * Math.min(p, 1 - p), 0.5 * dof, 0.5);
-  x3 = Math.sqrt(dof * (1 - x3) / x3);
-  return p > 0.5 ? x3 : -x3;
-}
-
 // src/marks/RegressionMark.js
 var RegressionMark = class extends Mark2 {
   constructor(source, options) {
@@ -40708,7 +41315,7 @@ function concat(a2, b) {
   return array4;
 }
 function linePoints(fit2) {
-  const { x0: x06, x1: x12, xm, intercept, slope, n, ssx, ssy, ...rest } = fit2.columns;
+  const { x0: x06 = [], x1: x12 = [], xm, intercept, slope, n, ssx, ssy, ...rest } = fit2.columns;
   const predict = (x4, i) => intercept[i] + x4 * slope[i];
   const x3 = concat(x06, x12);
   const y3 = concat(x06.map(predict), x12.map(predict));
@@ -40812,7 +41419,8 @@ var Highlight = class {
     for (let i = 0; i < nodes.length; ++i) {
       const node = nodes[i];
       const base = values2[i];
-      const t = test(node.__data__);
+      const data = node.__data__;
+      const t = test(Array.isArray(data) ? data[0] : data);
       for (let j = 0; j < channels.length; ++j) {
         const [attr, value] = channels[j];
         node.setAttribute(attr, t ? base[j] : value);
@@ -40828,8 +41436,10 @@ async function predicateFunction(mark, selection2) {
   const filter3 = mark.filterBy?.predicate(mark, true);
   const s2 = { __: and(pred) };
   const q = mark.query(filter3);
-  const p = q.groupby().length ? q.select(s2) : q.$select(s2);
-  const data = await mark.coordinator.query(p);
+  (q.queries || [q]).forEach((q2) => {
+    q2.groupby().length ? q2.select(s2) : q2.$select(s2);
+  });
+  const data = await mark.coordinator.query(q);
   const v2 = data.getChild?.("__");
   return !(data.numRows || data.length) ? () => false : v2 ? (i) => v2.get(i) : (i) => data[i].__;
 }
@@ -40935,13 +41545,12 @@ var Interval1D = class {
   }
   clause(value) {
     const { mark, pixelSize, field: field2, scale: scale3 } = this;
-    return {
+    return clauseInterval(field2, value, {
       source: this,
-      schema: { type: "interval", pixelSize, scales: [scale3] },
       clients: this.peers ? mark.plot.markSet : (/* @__PURE__ */ new Set()).add(mark),
-      value,
-      predicate: value ? isBetween(field2, value) : null
-    };
+      scale: scale3,
+      pixelSize
+    });
   }
   init(svg, root2) {
     const { brush: brush3, channel, style } = this;
@@ -40949,9 +41558,10 @@ var Interval1D = class {
     const rx = svg.scale("x").range;
     const ry = svg.scale("y").range;
     brush3.extent([[min2(rx), min2(ry)], [max2(rx), max2(ry)]]);
+    const range3 = this.value?.map(this.scale.apply).sort(ascending);
     const facets = select_default2(svg).selectAll('g[aria-label="facet"]');
     root2 = facets.size() ? facets : select_default2(root2 ?? svg);
-    this.g = root2.append("g").attr("class", `interval-${channel}`).each(patchScreenCTM).call(brush3).call(brush3.moveSilent, this.value?.map(this.scale.apply));
+    this.g = root2.append("g").attr("class", `interval-${channel}`).each(patchScreenCTM).call(brush3).call(brush3.moveSilent, range3);
     if (style) {
       const brushes = this.g.selectAll("rect.selection");
       for (const name in style) {
@@ -40965,7 +41575,6 @@ var Interval1D = class {
 };
 
 // src/interactors/Interval2D.js
-var asc = (a2, b) => a2 - b;
 var Interval2D = class {
   constructor(mark, {
     selection: selection2,
@@ -40998,8 +41607,8 @@ var Interval2D = class {
     let yr = void 0;
     if (extent4) {
       const [a2, b] = extent4;
-      xr = [a2[0], b[0]].map((v2) => invert(v2, xscale, pixelSize)).sort(asc);
-      yr = [a2[1], b[1]].map((v2) => invert(v2, yscale, pixelSize)).sort(asc);
+      xr = [a2[0], b[0]].map((v2) => invert(v2, xscale, pixelSize)).sort(ascending);
+      yr = [a2[1], b[1]].map((v2) => invert(v2, yscale, pixelSize)).sort(ascending);
     }
     if (!closeTo(xr, value?.[0]) || !closeTo(yr, value?.[1])) {
       this.value = extent4 ? [xr, yr] : void 0;
@@ -41009,13 +41618,12 @@ var Interval2D = class {
   }
   clause(value) {
     const { mark, pixelSize, xfield, yfield, xscale, yscale } = this;
-    return {
+    return clauseIntervals([xfield, yfield], value, {
       source: this,
-      schema: { type: "interval", pixelSize, scales: [xscale, yscale] },
       clients: this.peers ? mark.plot.markSet : (/* @__PURE__ */ new Set()).add(mark),
-      value,
-      predicate: value ? and(isBetween(xfield, value[0]), isBetween(yfield, value[1])) : null
-    };
+      scales: [xscale, yscale],
+      pixelSize
+    });
   }
   init(svg) {
     const { brush: brush3, style } = this;
@@ -41034,8 +41642,8 @@ var Interval2D = class {
       }
     }
     if (this.value) {
-      const [x12, x22] = this.value[0].map(xscale.apply).sort(asc);
-      const [y12, y22] = this.value[1].map(yscale.apply).sort(asc);
+      const [x12, x22] = this.value[0].map(xscale.apply).sort(ascending);
+      const [y12, y22] = this.value[1].map(yscale.apply).sort(ascending);
       this.g.call(brush3.moveSilent, [[x12, y12], [x22, y22]]);
     }
     svg.addEventListener("pointerenter", (evt) => {
@@ -41048,61 +41656,83 @@ var Interval2D = class {
 var Nearest = class {
   constructor(mark, {
     selection: selection2,
-    channel,
-    field: field2
+    pointer: pointer2,
+    channels,
+    fields,
+    maxRadius = 40
   }) {
     this.mark = mark;
     this.selection = selection2;
     this.clients = (/* @__PURE__ */ new Set()).add(mark);
-    this.channel = channel;
-    this.field = field2 || getField(mark, [channel]);
+    this.pointer = pointer2;
+    this.channels = channels || (pointer2 === "x" ? ["x"] : pointer2 === "y" ? ["y"] : ["x", "y"]);
+    this.fields = fields || this.channels.map((c4) => getField(mark, [c4]));
+    this.maxRadius = maxRadius;
+    this.valueIndex = -1;
   }
   clause(value) {
-    const { clients, field: field2 } = this;
-    const predicate = value ? eq(field2, literal(value)) : null;
-    return {
+    const { clients, fields } = this;
+    return clausePoints(fields, value ? [value] : value, {
       source: this,
-      schema: { type: "point" },
-      clients,
-      value,
-      predicate
-    };
+      clients
+    });
   }
   init(svg) {
     const that = this;
-    const { mark, channel, selection: selection2 } = this;
-    const { data } = mark;
-    const key = mark.channelField(channel).as;
+    const { mark, channels, selection: selection2, maxRadius } = this;
+    const { data: { columns } } = mark;
+    const keys = channels.map((c4) => mark.channelField(c4).as);
+    const param = !isSelection(selection2);
     const facets = select_default2(svg).selectAll('g[aria-label="facet"]');
     const root2 = facets.size() ? facets : select_default2(svg);
-    const scale3 = svg.scale(channel);
-    const param = !isSelection(selection2);
-    root2.on("pointerdown pointermove", function(evt) {
-      const [x3, y3] = pointer_default(evt, this);
-      const z = findNearest(data.columns[key], scale3.invert(channel === "x" ? x3 : y3));
-      selection2.update(param ? z : that.clause(z));
+    const xscale = svg.scale("x").apply;
+    const yscale = svg.scale("y").apply;
+    const X3 = Array.from(columns[mark.channelField("x").as], xscale);
+    const Y3 = Array.from(columns[mark.channelField("y").as], yscale);
+    const sx = this.pointer === "y" ? 0.01 : 1;
+    const sy = this.pointer === "x" ? 0.01 : 1;
+    root2.on("pointerenter pointerdown pointermove", function(evt) {
+      const [px, py] = pointer_default(evt, this);
+      const i = findNearest(X3, Y3, px, py, sx, sy, maxRadius);
+      if (i !== this.valueIndex) {
+        this.valueIndex = i;
+        const v2 = i < 0 ? void 0 : keys.map((k2) => columns[k2][i]);
+        if (param) {
+          if (i > -1) selection2.update(v2.length > 1 ? v2 : v2[0]);
+        } else {
+          selection2.update(that.clause(v2));
+        }
+      }
     });
     if (param) return;
+    root2.on("pointerleave", () => {
+      selection2.update(that.clause(void 0));
+    });
     svg.addEventListener("pointerenter", (evt) => {
-      if (!evt.buttons) this.selection.activate(this.clause(0));
+      if (!evt.buttons) {
+        const v2 = this.channels.map(() => 0);
+        selection2.activate(this.clause(v2));
+      }
     });
   }
 };
-function findNearest(values2, value) {
-  let dist2 = Infinity;
-  let nearest;
-  for (let i = 0; i < values2.length; ++i) {
-    const delta = Math.abs(values2[i] - value);
-    if (delta < dist2) {
-      dist2 = delta;
-      nearest = values2[i];
+function findNearest(x3, y3, px, py, sx, sy, maxRadius) {
+  let dist2 = maxRadius * maxRadius;
+  let nearest = -1;
+  for (let i = 0; i < x3.length; ++i) {
+    const dx = sx * (x3[i] - px);
+    const dy = sy * (y3[i] - py);
+    const dd = dx * dx + dy * dy;
+    if (dd <= dist2) {
+      dist2 = dd;
+      nearest = i;
     }
   }
   return nearest;
 }
 
 // src/interactors/PanZoom.js
-var asc2 = (a2, b) => a2 - b;
+var asc = (a2, b) => a2 - b;
 var PanZoom = class {
   constructor(mark, {
     x: x3 = new Selection(),
@@ -41144,13 +41774,11 @@ var PanZoom = class {
     }
   }
   clause(value, field2, scale3) {
-    return {
+    return clauseInterval(field2, value, {
       source: this,
-      schema: { type: "interval", scales: [scale3] },
       clients: this.mark.plot.markSet,
-      value,
-      predicate: value ? isBetween(field2, value) : null
-    };
+      scale: scale3
+    });
   }
   init(svg) {
     this.svg = svg;
@@ -41159,8 +41787,8 @@ var PanZoom = class {
     const { panx, pany, mark: { plot: { element } }, xsel, ysel } = this;
     this.xscale = svg.scale("x");
     this.yscale = svg.scale("y");
-    const rx = this.xscale.range.slice().sort(asc2);
-    const ry = this.yscale.range.slice().sort(asc2);
+    const rx = this.xscale.range.slice().sort(asc);
+    const ry = this.yscale.range.slice().sort(asc);
     const tx = extent3(panx, [-Infinity, Infinity], rx);
     const ty = extent3(pany, [-Infinity, Infinity], ry);
     const z = zoom_default2().extent([[rx[0], ry[0]], [rx[1], ry[1]]]).scaleExtent(this.zoom).translateExtent([[tx[0], ty[0]], [tx[1], ty[1]]]).on("start", () => {
@@ -41212,42 +41840,35 @@ var Toggle = class {
     this.mark = mark;
     this.selection = selection2;
     this.peers = peers;
-    this.channels = channels.map((c4) => {
+    const fields = this.fields = [];
+    const as = this.as = [];
+    channels.forEach((c4) => {
       const q = c4 === "color" ? ["color", "fill", "stroke"] : c4 === "x" ? ["x", "x1", "x2"] : c4 === "y" ? ["y", "y1", "y2"] : [c4];
       for (let i = 0; i < q.length; ++i) {
         const f = mark.channelField(q[i], { exact: true });
-        if (f) return {
-          field: f.field?.basis || f.field,
-          as: f.as
-        };
+        if (f) {
+          fields.push(f.field?.basis || f.field);
+          as.push(f.as);
+          return;
+        }
       }
       throw new Error(`Missing channel: ${c4}`);
     });
   }
   clause(value) {
-    const { channels, mark } = this;
-    let predicate = null;
-    if (value) {
-      const clauses = value.map((vals) => {
-        const list = vals.map((v2, i) => {
-          return isNotDistinct(channels[i].field, literal(v2));
-        });
-        return list.length > 1 ? and(list) : list[0];
-      });
-      predicate = clauses.length > 1 ? or(clauses) : clauses[0];
-    }
-    return {
+    const { fields, mark } = this;
+    return clausePoints(fields, value, {
       source: this,
-      schema: { type: "point" },
-      clients: this.peers ? mark.plot.markSet : (/* @__PURE__ */ new Set()).add(mark),
-      value,
-      predicate
-    };
+      clients: this.peers ? mark.plot.markSet : (/* @__PURE__ */ new Set()).add(mark)
+    });
   }
   init(svg, selector, accessor) {
-    const { mark, channels, selection: selection2 } = this;
+    const { mark, as, selection: selection2 } = this;
     const { data: { columns = {} } = {} } = mark;
-    accessor ??= (target) => channels.map((c4) => columns[c4.as][target.__data__]);
+    accessor ??= (target) => as.map((name) => {
+      const data = target.__data__;
+      return columns[name][Array.isArray(data) ? data[0] : data];
+    });
     selector ??= `[data-index="${mark.index}"]`;
     const groups2 = new Set(svg.querySelectorAll(selector));
     svg.addEventListener("pointerdown", (evt) => {
@@ -41272,7 +41893,7 @@ var Toggle = class {
     });
     svg.addEventListener("pointerenter", (evt) => {
       if (evt.buttons) return;
-      this.selection.activate(this.clause([this.channels.map(() => 0)]));
+      this.selection.activate(this.clause([this.fields.map(() => 0)]));
     });
   }
 };
@@ -41299,7 +41920,7 @@ var Legend = class {
   constructor(channel, options) {
     const { as, field: field2, ...rest } = options;
     this.channel = channel;
-    this.options = { label: null, ...rest };
+    this.options = rest;
     this.type = null;
     this.handler = null;
     this.selection = as;
@@ -41307,7 +41928,7 @@ var Legend = class {
     this.legend = null;
     this.element = document.createElement("div");
     this.element.setAttribute("class", "legend");
-    Object.assign(this.element, { value: this });
+    Object.defineProperty(this.element, "value", { value: this });
   }
   setPlot(plot2) {
     this.plot = plot2;
@@ -41319,8 +41940,10 @@ var Legend = class {
   }
   update() {
     if (!this.legend) return;
-    const { value } = this.selection;
-    const curr = value && value.length ? new Set(value.map((v2) => v2[0])) : null;
+    const { selection: selection2, handler } = this;
+    const { single, value } = selection2;
+    const vals = single ? value : selection2.valueFor(handler);
+    const curr = vals && vals.length ? new Set(vals.map((v2) => v2[0])) : null;
     const nodes = this.legend.querySelectorAll(TOGGLE_SELECTOR);
     for (const node of nodes) {
       const selected = curr ? curr.has(node.__data__) : true;
@@ -41329,9 +41952,13 @@ var Legend = class {
   }
 };
 function createLegend(legend2, svg) {
-  const { channel, options, selection: selection2 } = legend2;
+  const { channel, plot: plot2, selection: selection2 } = legend2;
   const scale3 = svg.scale(channel);
   const type2 = scale3.type === "ordinal" ? SWATCH : RAMP;
+  const options = {
+    label: plot2.getAttribute(`${channel}Label`) ?? null,
+    ...legend2.options
+  };
   const opt = type2 === SWATCH ? options : options.label ? { tickSize: 2, ...options } : { tickSize: 2, marginTop: 1, height: 29, ...options };
   const el = svg.legend(channel, opt);
   legend2.legend = el;
@@ -41363,11 +41990,19 @@ function getInteractor(legend2, type2) {
   if (handler) return handler;
   const mark = interactorMark(legend2);
   if (type2 === SWATCH) {
-    legend2.handler = new Toggle(mark, { selection: selection2, channels: [channel] });
+    legend2.handler = new Toggle(mark, {
+      selection: selection2,
+      channels: [channel],
+      peers: false
+    });
     selection2.addEventListener("value", () => legend2.update());
   } else {
-    const brush3 = { fill: "none", stroke: "currentColor" };
-    legend2.handler = new Interval1D(mark, { selection: selection2, channel, brush: brush3 });
+    legend2.handler = new Interval1D(mark, {
+      selection: selection2,
+      channel,
+      brush: { fill: "none", stroke: "currentColor" },
+      peers: false
+    });
   }
   return legend2.handler;
 }
@@ -41413,11 +42048,104 @@ function spatialScale(sourceScale, width) {
   return scale2({ x: { ...rest, type: type2, range: [0, width] } });
 }
 
+// src/transforms/bin-step.js
+function binStep(span, steps, minstep = 0, logb = Math.LN10) {
+  let v2;
+  const level = Math.ceil(Math.log(steps) / logb);
+  let step = Math.max(
+    minstep,
+    Math.pow(10, Math.round(Math.log(span) / logb) - level)
+  );
+  while (Math.ceil(span / step) > steps) {
+    step *= 10;
+  }
+  const div = [5, 2];
+  for (let i = 0, n = div.length; i < n; ++i) {
+    v2 = step / div[i];
+    if (v2 >= minstep && span / v2 <= steps) step = v2;
+  }
+  return step;
+}
+function bins(min5, max4, options) {
+  let { step, steps, minstep = 0, nice: nice3 = true } = options;
+  if (nice3 !== false) {
+    const span = max4 - min5;
+    const logb = Math.LN10;
+    step = step || binStep(span, steps || 25, minstep, logb);
+    let v2 = Math.log(step);
+    const precision = v2 >= 0 ? 0 : ~~(-v2 / logb) + 1;
+    const eps2 = Math.pow(10, -precision - 1);
+    v2 = Math.floor(min5 / step + eps2) * step;
+    min5 = min5 < v2 ? v2 - step : v2;
+    max4 = Math.ceil(max4 / step) * step;
+    steps = Math.round((max4 - min5) / step);
+  }
+  return { min: min5, max: max4, steps };
+}
+
+// src/transforms/time-interval.js
+var YEAR = "year";
+var MONTH = "month";
+var DAY = "day";
+var HOUR = "hour";
+var MINUTE = "minute";
+var SECOND = "second";
+var MILLISECOND = "millisecond";
+var durationSecond3 = 1e3;
+var durationMinute3 = durationSecond3 * 60;
+var durationHour3 = durationMinute3 * 60;
+var durationDay3 = durationHour3 * 24;
+var durationWeek3 = durationDay3 * 7;
+var durationMonth3 = durationDay3 * 30;
+var durationYear3 = durationDay3 * 365;
+var intervals = [
+  [SECOND, 1, durationSecond3],
+  [SECOND, 5, 5 * durationSecond3],
+  [SECOND, 15, 15 * durationSecond3],
+  [SECOND, 30, 30 * durationSecond3],
+  [MINUTE, 1, durationMinute3],
+  [MINUTE, 5, 5 * durationMinute3],
+  [MINUTE, 15, 15 * durationMinute3],
+  [MINUTE, 30, 30 * durationMinute3],
+  [HOUR, 1, durationHour3],
+  [HOUR, 3, 3 * durationHour3],
+  [HOUR, 6, 6 * durationHour3],
+  [HOUR, 12, 12 * durationHour3],
+  [DAY, 1, durationDay3],
+  [DAY, 7, durationWeek3],
+  [MONTH, 1, durationMonth3],
+  [MONTH, 3, 3 * durationMonth3],
+  [YEAR, 1, durationYear3]
+];
+function timeInterval3(min5, max4, steps) {
+  const span = max4 - min5;
+  const target = span / steps;
+  let i = bisector((i2) => i2[2]).right(intervals, target);
+  if (i === intervals.length) {
+    return { interval: YEAR, step: binStep(span, steps) };
+  } else if (i) {
+    i = intervals[target / intervals[i - 1][2] < intervals[i][2] / target ? i - 1 : i];
+    return { interval: i[0], step: i[1] };
+  } else {
+    return { interval: MILLISECOND, step: binStep(span, steps, 1) };
+  }
+}
+
 // src/transforms/bin.js
-var EXTENT = /* @__PURE__ */ new Set(["rectY-x", "rectX-y", "rect-x", "rect-y"]);
-function bin2(field2, options = { steps: 25 }) {
+var EXTENT = /* @__PURE__ */ new Set([
+  "rectY-x",
+  "rectX-y",
+  "rect-x",
+  "rect-y",
+  "ruleY-x",
+  "ruleX-y"
+]);
+function hasExtent(mark, channel) {
+  return EXTENT.has(`${mark.type}-${channel}`);
+}
+function bin2(field2, options = {}) {
   const fn = (mark, channel) => {
-    if (EXTENT.has(`${mark.type}-${channel}`)) {
+    if (hasExtent(mark, channel)) {
       return {
         [`${channel}1`]: binField(mark, channel, field2, options),
         [`${channel}2`]: binField(mark, channel, field2, { ...options, offset: 1 })
@@ -41435,57 +42163,39 @@ function binField(mark, channel, column3, options) {
   return {
     column: column3,
     label: column3,
-    get stats() {
-      return { column: column3, stats: ["min", "max"] };
-    },
     get columns() {
       return [column3];
     },
     get basis() {
       return column3;
     },
+    get stats() {
+      return { column: column3, stats: ["min", "max"] };
+    },
     toString() {
-      const { apply: apply2, sqlApply, sqlInvert } = channelScale(mark, channel);
-      const { min: min5, max: max4 } = mark.channelField(channel);
-      const b = bins(apply2(min5), apply2(max4), options);
-      const col = sqlApply(column3);
-      const base = b.min === 0 ? col : `(${col} - ${b.min})`;
-      const alpha = `${(b.max - b.min) / b.steps}::DOUBLE`;
-      const off = options.offset ? `${options.offset} + ` : "";
-      const expr = `${b.min} + ${alpha} * (${off}FLOOR(${base} / ${alpha}))`;
-      return `${sqlInvert(expr)}`;
+      const { type: type2, min: min5, max: max4 } = mark.channelField(channel);
+      const { interval: i, steps, offset: offset2 = 0 } = options;
+      const interval2 = i ?? (type2 === "date" || hasTimeScale(mark, channel) ? "date" : "number");
+      if (interval2 === "number") {
+        const { apply: apply2, sqlApply, sqlInvert } = channelScale(mark, channel);
+        const b = bins(apply2(min5), apply2(max4), options);
+        const col = sqlApply(column3);
+        const base = b.min === 0 ? col : `(${col} - ${b.min})`;
+        const alpha = `${(b.max - b.min) / b.steps}::DOUBLE`;
+        const off = offset2 ? `${offset2} + ` : "";
+        const expr = `${b.min} + ${alpha} * (${off}FLOOR(${base} / ${alpha}))`;
+        return `${sqlInvert(expr)}`;
+      } else {
+        const { interval: unit3, step = 1 } = interval2 === "date" ? timeInterval3(min5, max4, steps || 40) : options;
+        const off = offset2 ? ` + INTERVAL ${offset2 * step} ${unit3}` : "";
+        return `(${dateBin(column3, unit3, step)}${off})`;
+      }
     }
   };
 }
-function bins(min5, max4, options) {
-  let { steps = 25, minstep = 0, nice: nice3 = true } = options;
-  if (nice3 !== false) {
-    const span = max4 - min5;
-    const maxb = steps;
-    const logb = Math.LN10;
-    const level = Math.ceil(Math.log(maxb) / logb);
-    let step = Math.max(
-      minstep,
-      Math.pow(10, Math.round(Math.log(span) / logb) - level)
-    );
-    while (Math.ceil(span / step) > maxb) {
-      step *= 10;
-    }
-    const div = [5, 2];
-    let v2;
-    for (let i = 0, n = div.length; i < n; ++i) {
-      v2 = step / div[i];
-      if (v2 >= minstep && span / v2 <= maxb) step = v2;
-    }
-    v2 = Math.log(step);
-    const precision = v2 >= 0 ? 0 : ~~(-v2 / logb) + 1;
-    const eps2 = Math.pow(10, -precision - 1);
-    v2 = Math.floor(min5 / step + eps2) * step;
-    min5 = min5 < v2 ? v2 - step : v2;
-    max4 = Math.ceil(max4 / step) * step;
-    steps = Math.round((max4 - min5) / step);
-  }
-  return { min: min5, max: max4, steps };
+function hasTimeScale(mark, channel) {
+  const scale3 = mark.plot.getAttribute(`${channel}Scale`);
+  return scale3 === "utc" || scale3 === "time";
 }
 export {
   ConnectedMark,
@@ -41493,6 +42203,7 @@ export {
   DenseLineMark,
   Density1DMark,
   Density2DMark,
+  ErrorBarMark,
   Fixed,
   GeoMark,
   Grid2DMark,