@uwdata/mosaic-plot 0.6.1 → 0.7.0

package/dist/mosaic-plot.js

@@ -12864,6 +12864,15 @@ var Query = class _Query {
   static except(...queries) {
     return new SetOperation("EXCEPT", queries.flat());
   }
+  static describe(query) {
+    const q = query.clone();
+    const { clone, toString } = q;
+    return Object.assign(q, {
+      describe: true,
+      clone: () => _Query.describe(clone.call(q)),
+      toString: () => `DESCRIBE ${toString.call(q)}`
+    });
+  }
   constructor() {
     this.query = {
       with: [],
@@ -13098,6 +13107,7 @@ var Query = class _Query {
   }
   toString() {
     const {
+      with: cte,
       select: select2,
       distinct: distinct2,
       from,
@@ -13109,8 +13119,7 @@ var Query = class _Query {
       qualify,
       orderby,
       limit,
-      offset: offset2,
-      with: cte
+      offset: offset2
     } = this.query;
     const sql2 = [];
     if (cte.length) {
@@ -13232,6 +13241,9 @@ var SetOperation = class _SetOperation {
 function isQuery(value) {
   return value instanceof Query || value instanceof SetOperation;
 }
+function isDescribeQuery(value) {
+  return isQuery(value) && value.describe;
+}
 function unquote(s2) {
   return isDoubleQuoted(s2) ? s2.slice(1, -1) : s2;
 }
@@ -13331,131 +13343,6 @@ function create(name, query, {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// ../core/src/util/js-type.js
-function jsType(type2) {
-  switch (type2) {
-    case "BIGINT":
-    case "HUGEINT":
-    case "INTEGER":
-    case "SMALLINT":
-    case "TINYINT":
-    case "UBIGINT":
-    case "UINTEGER":
-    case "USMALLINT":
-    case "UTINYINT":
-    case "DOUBLE":
-    case "FLOAT":
-    case "REAL":
-    case "DECIMAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-    case "TIME":
-    case "TIMESTAMP_NS":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-      return "string";
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-      return "object";
-    default:
-      throw new Error(`Unsupported type: ${type2}`);
-  }
-}
-
-// ../core/src/util/summarize.js
-var Count = "count";
-var Nulls = "nulls";
-var Max = "max";
-var Min = "min";
-var Distinct = "distinct";
-var statMap = {
-  [Count]: count,
-  [Distinct]: (column3) => count(column3).distinct(),
-  [Max]: max,
-  [Min]: min,
-  [Nulls]: (column3) => count().where(isNull(column3))
-};
-function summarize({ table, column: column3 }, stats) {
-  return Query.from(table).select(stats.map((s2) => [s2, statMap[s2](column3)]));
-}
-
-// ../core/src/Catalog.js
-var object = () => /* @__PURE__ */ Object.create(null);
-var Catalog = class {
-  constructor(coordinator2) {
-    this.mc = coordinator2;
-    this.clear();
-  }
-  clear() {
-    this.tables = object();
-  }
-  tableInfo(table) {
-    const cache = this.tables;
-    if (cache[table]) {
-      return cache[table];
-    }
-    const infoPromise = getTableInfo(this.mc, table).catch((err) => {
-      cache[table] = null;
-      throw err;
-    });
-    return cache[table] = infoPromise;
-  }
-  async fieldInfo({ table, column: column3, stats }) {
-    const tableInfo = await this.tableInfo(table);
-    const colInfo = tableInfo[column3];
-    if (colInfo == null)
-      return;
-    if (!stats?.length)
-      return colInfo;
-    const result = await this.mc.query(
-      summarize(colInfo, stats),
-      { persist: true }
-    );
-    const info = { ...colInfo, ...Array.from(result)[0] };
-    for (const key in info) {
-      const value = info[key];
-      if (typeof value === "bigint") {
-        info[key] = Number(value);
-      }
-    }
-    return info;
-  }
-  async queryFields(fields) {
-    const list = await resolveFields(this, fields);
-    const data = await Promise.all(list.map((f) => this.fieldInfo(f)));
-    return data.filter((x3) => x3);
-  }
-};
-async function getTableInfo(mc, table) {
-  const result = await mc.query(
-    `DESCRIBE ${asRelation(table)}`,
-    { type: "json", cache: false }
-  );
-  const columns = object();
-  for (const entry of result) {
-    columns[entry.column_name] = {
-      table,
-      column: entry.column_name,
-      sqlType: entry.column_type,
-      type: jsType(entry.column_type),
-      nullable: entry.null === "YES"
-    };
-  }
-  return columns;
-}
-async function resolveFields(catalog, list) {
-  return list.length === 1 && list[0].column === "*" ? Object.values(await catalog.tableInfo(list[0].table)) : list;
-}
-
 // ../core/src/util/hash.js
 function fnv_hash(v2) {
   let a2 = 2166136261;
@@ -13815,7 +13702,7 @@ function consolidate(group3, enqueue, record) {
         type: "arrow",
         cache: false,
         record: false,
-        query: consolidatedQuery(group3, record)
+        query: group3.query = consolidatedQuery(group3, record)
       },
       result: group3.result = queryResult()
     });
@@ -13863,7 +13750,7 @@ function consolidatedQuery(group3, record) {
   return query.$select(Array.from(fields.values()));
 }
 async function processResults(group3, cache) {
-  const { maps, result } = group3;
+  const { maps, query, result } = group3;
   if (!maps)
     return;
   let data;
@@ -13875,25 +13762,33 @@ async function processResults(group3, cache) {
     }
     return;
   }
+  const describe = isDescribeQuery(query);
   group3.forEach(({ entry }, index2) => {
     const { request, result: result2 } = entry;
-    const projected = projectResult(data, maps[index2]);
+    const map4 = maps[index2];
+    const extract = describe && map4 ? filterResult(data, map4) : map4 ? projectResult(data, map4) : data;
     if (request.cache) {
-      cache.set(String(request.query), projected);
+      cache.set(String(request.query), extract);
     }
-    result2.fulfill(projected);
+    result2.fulfill(extract);
   });
 }
 function projectResult(data, map4) {
-  if (map4) {
-    const cols = {};
-    for (const [name, as] of map4) {
-      cols[as] = data.getChild(name);
+  const cols = {};
+  for (const [name, as] of map4) {
+    cols[as] = data.getChild(name);
+  }
+  return new data.constructor(cols);
+}
+function filterResult(data, map4) {
+  const lookup = new Map(map4);
+  const result = [];
+  for (const d of data) {
+    if (lookup.has(d.column_name)) {
+      result.push({ ...d, column_name: lookup.get(d.column_name) });
     }
-    return new data.constructor(cols);
-  } else {
-    return data;
   }
+  return result;
 }
 
 // ../core/src/util/cache.js
@@ -14140,6 +14035,197 @@ function QueryManager() {
   };
 }
 
+// ../core/src/util/js-type.js
+function jsType(type2) {
+  switch (type2) {
+    case "BIGINT":
+    case "HUGEINT":
+    case "INTEGER":
+    case "SMALLINT":
+    case "TINYINT":
+    case "UBIGINT":
+    case "UINTEGER":
+    case "USMALLINT":
+    case "UTINYINT":
+    case "DOUBLE":
+    case "FLOAT":
+    case "REAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+    case "TIME":
+    case "TIMESTAMP_NS":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+      return "string";
+    case "ARRAY":
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+    case "GEOMETRY":
+      return "object";
+    default:
+      if (type2.startsWith("DECIMAL")) {
+        return "number";
+      } else if (type2.startsWith("STRUCT") || type2.startsWith("MAP")) {
+        return "object";
+      } else if (type2.endsWith("]")) {
+        return "array";
+      }
+      throw new Error(`Unsupported type: ${type2}`);
+  }
+}
+
+// ../core/src/util/convert-arrow.js
+var INTEGER = 2;
+var FLOAT = 3;
+var DECIMAL = 7;
+var TIMESTAMP = 10;
+function isArrowTable(values2) {
+  return typeof values2?.getChild === "function";
+}
+function convertArrowArrayType(type2) {
+  switch (type2.typeId) {
+    case INTEGER:
+    case FLOAT:
+    case DECIMAL:
+      return Float64Array;
+    default:
+      return Array;
+  }
+}
+function convertArrowValue(type2) {
+  const { typeId } = type2;
+  if (typeId === TIMESTAMP) {
+    return (v2) => v2 == null ? v2 : new Date(v2);
+  }
+  if (typeId === INTEGER && type2.bitWidth >= 64) {
+    return (v2) => v2 == null ? v2 : Number(v2);
+  }
+  if (typeId === DECIMAL) {
+    const scale3 = 1 / Math.pow(10, type2.scale);
+    return (v2) => v2 == null ? v2 : decimalToNumber(v2, scale3);
+  }
+  return (v2) => v2;
+}
+function convertArrowColumn(column3) {
+  const { type: type2 } = column3;
+  const { typeId } = type2;
+  if (typeId === TIMESTAMP) {
+    const size = column3.length;
+    const array3 = new Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column3.get(row);
+      array3[row] = v2 == null ? null : new Date(v2);
+    }
+    return array3;
+  }
+  if (typeId === INTEGER && type2.bitWidth >= 64) {
+    const size = column3.length;
+    const array3 = new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column3.get(row);
+      array3[row] = v2 == null ? NaN : Number(v2);
+    }
+    return array3;
+  }
+  if (typeId === DECIMAL) {
+    const scale3 = 1 / Math.pow(10, type2.scale);
+    const size = column3.length;
+    const array3 = new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column3.get(row);
+      array3[row] = v2 == null ? NaN : decimalToNumber(v2, scale3);
+    }
+    return array3;
+  }
+  return column3.toArray();
+}
+var BASE32 = Array.from(
+  { length: 8 },
+  (_, i) => Math.pow(2, i * 32)
+);
+function decimalToNumber(v2, scale3) {
+  const n = v2.length;
+  let x3 = 0;
+  if (v2.signed && (v2[n - 1] | 0) < 0) {
+    for (let i = 0; i < n; ++i) {
+      x3 += ~(v2[i] | 0) * BASE32[i];
+    }
+    x3 = -(x3 + 1);
+  } else {
+    for (let i = 0; i < n; ++i) {
+      x3 += v2[i] * BASE32[i];
+    }
+  }
+  return x3 * scale3;
+}
+
+// ../core/src/util/field-info.js
+var Count = "count";
+var Nulls = "nulls";
+var Max = "max";
+var Min = "min";
+var Distinct = "distinct";
+var statMap = {
+  [Count]: count,
+  [Distinct]: (column3) => count(column3).distinct(),
+  [Max]: max,
+  [Min]: min,
+  [Nulls]: (column3) => count().where(isNull(column3))
+};
+function summarize(table, column3, stats) {
+  return Query.from(table).select(Array.from(stats, (s2) => [s2, statMap[s2](column3)]));
+}
+async function queryFieldInfo(mc, fields) {
+  if (fields.length === 1 && `${fields[0].column}` === "*") {
+    return getTableInfo(mc, fields[0].table);
+  } else {
+    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x3) => x3);
+  }
+}
+async function getFieldInfo(mc, { table, column: column3, stats }) {
+  const q = Query.from({ source: table }).select({ column: column3 }).groupby(column3.aggregate ? sql`ALL` : []);
+  const [desc2] = Array.from(await mc.query(Query.describe(q)));
+  const info = {
+    table,
+    column: `${column3}`,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  };
+  if (!(stats?.length || stats?.size))
+    return info;
+  const result = await mc.query(
+    summarize(table, column3, stats),
+    { persist: true }
+  );
+  for (let i = 0; i < result.numCols; ++i) {
+    const { name } = result.schema.fields[i];
+    const child = result.getChildAt(i);
+    const convert = convertArrowValue(child.type);
+    info[name] = convert(child.get(0));
+  }
+  return info;
+}
+async function getTableInfo(mc, table) {
+  const result = await mc.query(`DESCRIBE ${asRelation(table)}`);
+  return Array.from(result).map((desc2) => ({
+    table,
+    column: desc2.column_name,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  }));
+}
+
 // ../core/src/util/void-logger.js
 function voidLogger() {
   return {
@@ -14172,7 +14258,6 @@ var Coordinator = class {
       logger = console,
       manager = QueryManager()
     } = options;
-    this.catalog = new Catalog(this);
     this.manager = manager;
     this.logger(logger);
     this.configure(options);
@@ -14191,7 +14276,7 @@ var Coordinator = class {
     this.manager.consolidate(consolidate2);
     this.indexes = indexes2;
   }
-  clear({ clients = true, cache = true, catalog = false } = {}) {
+  clear({ clients = true, cache = true } = {}) {
     this.manager.clear();
     if (clients) {
       this.clients?.forEach((client) => this.disconnect(client));
@@ -14201,8 +14286,6 @@ var Coordinator = class {
     }
     if (cache)
       this.manager.cache().clear();
-    if (catalog)
-      this.catalog.clear();
   }
   databaseConnector(db) {
     return this.manager.connector(db);
@@ -14255,7 +14338,7 @@ var Coordinator = class {
    * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
    */
   async connect(client) {
-    const { catalog, clients, filterGroups, indexes: indexes2 } = this;
+    const { clients, filterGroups, indexes: indexes2 } = this;
     if (clients.has(client)) {
       throw new Error("Client already connected.");
     }
@@ -14263,7 +14346,7 @@ var Coordinator = class {
     client.coordinator = this;
     const fields = client.fields();
     if (fields?.length) {
-      client.fieldInfo(await catalog.queryFields(fields));
+      client.fieldInfo(await queryFieldInfo(this, fields));
     }
     const filter3 = client.filterBy;
     if (filter3) {
@@ -21556,46 +21639,46 @@ function streamGeometry(geometry, stream) {
   }
 }
 var streamObjectType = {
-  Feature: function(object2, stream) {
-    streamGeometry(object2.geometry, stream);
+  Feature: function(object, stream) {
+    streamGeometry(object.geometry, stream);
   },
-  FeatureCollection: function(object2, stream) {
-    var features = object2.features, i = -1, n = features.length;
+  FeatureCollection: function(object, stream) {
+    var features = object.features, i = -1, n = features.length;
     while (++i < n)
       streamGeometry(features[i].geometry, stream);
   }
 };
 var streamGeometryType = {
-  Sphere: function(object2, stream) {
+  Sphere: function(object, stream) {
     stream.sphere();
   },
-  Point: function(object2, stream) {
-    object2 = object2.coordinates;
-    stream.point(object2[0], object2[1], object2[2]);
+  Point: function(object, stream) {
+    object = object.coordinates;
+    stream.point(object[0], object[1], object[2]);
   },
-  MultiPoint: function(object2, stream) {
-    var coordinates = object2.coordinates, i = -1, n = coordinates.length;
+  MultiPoint: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
     while (++i < n)
-      object2 = coordinates[i], stream.point(object2[0], object2[1], object2[2]);
+      object = coordinates[i], stream.point(object[0], object[1], object[2]);
   },
-  LineString: function(object2, stream) {
-    streamLine(object2.coordinates, stream, 0);
+  LineString: function(object, stream) {
+    streamLine(object.coordinates, stream, 0);
   },
-  MultiLineString: function(object2, stream) {
-    var coordinates = object2.coordinates, i = -1, n = coordinates.length;
+  MultiLineString: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
     while (++i < n)
       streamLine(coordinates[i], stream, 0);
   },
-  Polygon: function(object2, stream) {
-    streamPolygon(object2.coordinates, stream);
+  Polygon: function(object, stream) {
+    streamPolygon(object.coordinates, stream);
   },
-  MultiPolygon: function(object2, stream) {
-    var coordinates = object2.coordinates, i = -1, n = coordinates.length;
+  MultiPolygon: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
     while (++i < n)
       streamPolygon(coordinates[i], stream);
   },
-  GeometryCollection: function(object2, stream) {
-    var geometries = object2.geometries, i = -1, n = geometries.length;
+  GeometryCollection: function(object, stream) {
+    var geometries = object.geometries, i = -1, n = geometries.length;
     while (++i < n)
       streamGeometry(geometries[i], stream);
   }
@@ -21614,11 +21697,11 @@ function streamPolygon(coordinates, stream) {
     streamLine(coordinates[i], stream, 1);
   stream.polygonEnd();
 }
-function stream_default(object2, stream) {
-  if (object2 && streamObjectType.hasOwnProperty(object2.type)) {
-    streamObjectType[object2.type](object2, stream);
+function stream_default(object, stream) {
+  if (object && streamObjectType.hasOwnProperty(object.type)) {
+    streamObjectType[object.type](object, stream);
   } else {
-    streamGeometry(object2, stream);
+    streamGeometry(object, stream);
   }
 }
 
@@ -21742,12 +21825,12 @@ function centroidRingPoint(lambda, phi) {
   Z1 += w * (z0 + (z0 = z));
   centroidPointCartesian(x0, y0, z0);
 }
-function centroid_default(object2) {
+function centroid_default(object) {
   W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = 0;
   X2 = new Adder();
   Y2 = new Adder();
   Z2 = new Adder();
-  stream_default(object2, centroidStream);
+  stream_default(object, centroidStream);
   var x3 = +X2, y3 = +Y2, z = +Z2, m = hypot(x3, y3, z);
   if (m < epsilon22) {
     x3 = X1, y3 = Y1, z = Z1;
@@ -22931,28 +23014,28 @@ function appendRound2(digits) {
 // ../../node_modules/d3-geo/src/path/index.js
 function path_default(projection3, context) {
   let digits = 3, pointRadius = 4.5, projectionStream, contextStream;
-  function path2(object2) {
-    if (object2) {
+  function path2(object) {
+    if (object) {
       if (typeof pointRadius === "function")
         contextStream.pointRadius(+pointRadius.apply(this, arguments));
-      stream_default(object2, projectionStream(contextStream));
+      stream_default(object, projectionStream(contextStream));
     }
     return contextStream.result();
   }
-  path2.area = function(object2) {
-    stream_default(object2, projectionStream(area_default2));
+  path2.area = function(object) {
+    stream_default(object, projectionStream(area_default2));
     return area_default2.result();
   };
-  path2.measure = function(object2) {
-    stream_default(object2, projectionStream(measure_default));
+  path2.measure = function(object) {
+    stream_default(object, projectionStream(measure_default));
     return measure_default.result();
   };
-  path2.bounds = function(object2) {
-    stream_default(object2, projectionStream(bounds_default));
+  path2.bounds = function(object) {
+    stream_default(object, projectionStream(bounds_default));
     return bounds_default.result();
   };
-  path2.centroid = function(object2) {
-    stream_default(object2, projectionStream(centroid_default2));
+  path2.centroid = function(object) {
+    stream_default(object, projectionStream(centroid_default2));
     return centroid_default2.result();
   };
   path2.projection = function(_) {
@@ -23033,37 +23116,37 @@ TransformStream.prototype = {
 };
 
 // ../../node_modules/d3-geo/src/projection/fit.js
-function fit(projection3, fitBounds, object2) {
+function fit(projection3, fitBounds, object) {
   var clip = projection3.clipExtent && projection3.clipExtent();
   projection3.scale(150).translate([0, 0]);
   if (clip != null)
     projection3.clipExtent(null);
-  stream_default(object2, projection3.stream(bounds_default));
+  stream_default(object, projection3.stream(bounds_default));
   fitBounds(bounds_default.result());
   if (clip != null)
     projection3.clipExtent(clip);
   return projection3;
 }
-function fitExtent(projection3, extent4, object2) {
+function fitExtent(projection3, extent4, object) {
   return fit(projection3, function(b) {
     var w = extent4[1][0] - extent4[0][0], h = extent4[1][1] - extent4[0][1], k2 = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), x3 = +extent4[0][0] + (w - k2 * (b[1][0] + b[0][0])) / 2, y3 = +extent4[0][1] + (h - k2 * (b[1][1] + b[0][1])) / 2;
     projection3.scale(150 * k2).translate([x3, y3]);
-  }, object2);
+  }, object);
 }
-function fitSize(projection3, size, object2) {
-  return fitExtent(projection3, [[0, 0], size], object2);
+function fitSize(projection3, size, object) {
+  return fitExtent(projection3, [[0, 0], size], object);
 }
-function fitWidth(projection3, width, object2) {
+function fitWidth(projection3, width, object) {
   return fit(projection3, function(b) {
     var w = +width, k2 = w / (b[1][0] - b[0][0]), x3 = (w - k2 * (b[1][0] + b[0][0])) / 2, y3 = -k2 * b[0][1];
     projection3.scale(150 * k2).translate([x3, y3]);
-  }, object2);
+  }, object);
 }
-function fitHeight(projection3, height, object2) {
+function fitHeight(projection3, height, object) {
   return fit(projection3, function(b) {
     var h = +height, k2 = h / (b[1][1] - b[0][1]), x3 = -k2 * b[0][0], y3 = (h - k2 * (b[1][1] + b[0][1])) / 2;
     projection3.scale(150 * k2).translate([x3, y3]);
-  }, object2);
+  }, object);
 }
 
 // ../../node_modules/d3-geo/src/projection/resample.js
@@ -23235,17 +23318,17 @@ function projectionMutator(projectAt) {
   projection3.precision = function(_) {
     return arguments.length ? (projectResample = resample_default(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);
   };
-  projection3.fitExtent = function(extent4, object2) {
-    return fitExtent(projection3, extent4, object2);
+  projection3.fitExtent = function(extent4, object) {
+    return fitExtent(projection3, extent4, object);
   };
-  projection3.fitSize = function(size, object2) {
-    return fitSize(projection3, size, object2);
+  projection3.fitSize = function(size, object) {
+    return fitSize(projection3, size, object);
   };
-  projection3.fitWidth = function(width, object2) {
-    return fitWidth(projection3, width, object2);
+  projection3.fitWidth = function(width, object) {
+    return fitWidth(projection3, width, object);
   };
-  projection3.fitHeight = function(height, object2) {
-    return fitHeight(projection3, height, object2);
+  projection3.fitHeight = function(height, object) {
+    return fitHeight(projection3, height, object);
   };
   function recenter() {
     var center2 = scaleTranslateRotate(k2, 0, 0, sx, sy, alpha).apply(null, project2(lambda, phi)), transform3 = scaleTranslateRotate(k2, x3 - center2[0], y3 - center2[1], sx, sy, alpha);
@@ -23386,17 +23469,17 @@ function albersUsa_default() {
     hawaiiPoint = hawaii.translate([x3 - 0.205 * k2, y3 + 0.212 * k2]).clipExtent([[x3 - 0.214 * k2 + epsilon6, y3 + 0.166 * k2 + epsilon6], [x3 - 0.115 * k2 - epsilon6, y3 + 0.234 * k2 - epsilon6]]).stream(pointStream);
     return reset();
   };
-  albersUsa.fitExtent = function(extent4, object2) {
-    return fitExtent(albersUsa, extent4, object2);
+  albersUsa.fitExtent = function(extent4, object) {
+    return fitExtent(albersUsa, extent4, object);
   };
-  albersUsa.fitSize = function(size, object2) {
-    return fitSize(albersUsa, size, object2);
+  albersUsa.fitSize = function(size, object) {
+    return fitSize(albersUsa, size, object);
   };
-  albersUsa.fitWidth = function(width, object2) {
-    return fitWidth(albersUsa, width, object2);
+  albersUsa.fitWidth = function(width, object) {
+    return fitWidth(albersUsa, width, object);
   };
-  albersUsa.fitHeight = function(height, object2) {
-    return fitHeight(albersUsa, height, object2);
+  albersUsa.fitHeight = function(height, object) {
+    return fitHeight(albersUsa, height, object);
   };
   function reset() {
     cache = cacheStream = null;
@@ -29989,21 +30072,30 @@ function createProjection({
     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);
-        }
-      });
+      transform3 = Object.assign(
+        transform_default({
+          point(x3, y3) {
+            this.stream.point(x3 * k2 + tx, y3 * k2 + ty);
+          }
+        }),
+        { invert: ([x3, y3]) => [(x3 - tx) / k2, (y3 - ty) / k2] }
+      );
     } 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))) };
+  transform3 ??= tx === 0 && ty === 0 ? identity8() : Object.assign(
+    transform_default({
+      point(x3, y3) {
+        this.stream.point(x3 + tx, y3 + ty);
+      }
+    }),
+    { invert: ([x3, y3]) => [x3 - tx, y3 - ty] }
+  );
+  return {
+    stream: (s2) => projection3.stream(transform3.stream(clip(s2))),
+    invert: (p) => projection3.invert(transform3.invert(p))
+  };
 }
 function namedProjection(projection3) {
   switch (`${projection3}`.toLowerCase()) {
@@ -30089,13 +30181,19 @@ function conicProjection2(createProjection2, kx2, ky2) {
     aspectRatio
   };
 }
-var identity8 = constant({ stream: (stream) => stream });
+var identity8 = constant({
+  stream: (stream) => stream,
+  invert: (p) => p
+});
 var reflectY = constant(
-  transform_default({
-    point(x3, y3) {
-      this.stream.point(x3, -y3);
-    }
-  })
+  Object.assign(
+    transform_default({
+      point(x3, y3) {
+        this.stream.point(x3, -y3);
+      }
+    }),
+    { invert: ([x3, y3]) => [x3, -y3] }
+  )
 );
 function project(cx, cy, values2, projection3) {
   const x3 = values2[cx];
@@ -30174,8 +30272,8 @@ function getGeometryChannels(channel) {
     sphere() {
     }
   };
-  for (const object2 of channel.value)
-    stream_default(object2, sink);
+  for (const object of channel.value)
+    stream_default(object, sink);
   return [x3, y3];
 }
 
@@ -34258,6 +34356,7 @@ function plot(options = {}) {
   }
   figure.scale = exposeScales(scales2.scales);
   figure.legend = exposeLegends(scaleDescriptors, context, options);
+  figure.projection = context.projection;
   const w = consumeWarnings();
   if (w > 0) {
     select_default2(svg).append("text").attr("x", width).attr("y", 20).attr("dy", "-1em").attr("text-anchor", "end").attr("font-family", "initial").text("\u26A0\uFE0F").append("title").text(`${w.toLocaleString("en-US")} warning${w === 1 ? "" : "s"}. Please check the console.`);
@@ -39643,13 +39742,13 @@ var attributeMap = /* @__PURE__ */ new Map([
   ["projectionInsetBottom", "projection.insetBottom"],
   ["projectionClip", "projection.clip"]
 ]);
-function setProperty(object2, path2, value) {
+function setProperty(object, path2, value) {
   for (let i = 0; i < path2.length; ++i) {
     const key = path2[i];
     if (i === path2.length - 1) {
-      object2[key] = value;
+      object[key] = value;
     } else {
-      object2 = object2[key] || (object2[key] = {});
+      object = object[key] || (object[key] = {});
     }
   }
 }
@@ -39719,16 +39818,16 @@ function setSymbolAttributes(plot2, svg, attributes, symbols3) {
 }
 function inferLabels(spec, plot2) {
   const { marks: marks2 } = plot2;
-  inferLabel("x", spec, marks2, ["x", "x1", "x2"]);
-  inferLabel("y", spec, marks2, ["y", "y1", "y2"]);
+  inferLabel("x", spec, marks2);
+  inferLabel("y", spec, marks2);
   inferLabel("fx", spec, marks2);
   inferLabel("fy", spec, marks2);
 }
-function inferLabel(key, spec, marks2, channels = [key]) {
+function inferLabel(key, spec, marks2) {
   const scale3 = spec[key] || {};
   if (scale3.axis === null || scale3.label !== void 0)
     return;
-  const fields = marks2.map((mark) => mark.channelField(channels)?.field);
+  const fields = marks2.map((mark) => mark.channelField(key)?.field);
   if (fields.every((x3) => x3 == null))
     return;
   let candCol;
@@ -39741,7 +39840,7 @@ function inferLabel(key, spec, marks2, channels = [key]) {
     } else if (candCol === void 0 && candLabel === void 0) {
       candCol = column3;
       candLabel = label;
-      type2 = getType(marks2[i].data, channels) || "number";
+      type2 = getType(marks2[i].data, key) || "number";
     } else if (candLabel !== label) {
       candLabel = void 0;
     } else if (candCol !== column3) {
@@ -39783,13 +39882,11 @@ function annotateMarks(svg, indices) {
     }
   }
 }
-function getType(data, channels) {
+function getType(data, channel) {
   for (const row of data) {
-    for (let j = 0; j < channels.length; ++j) {
-      const v2 = row[channels[j]];
-      if (v2 != null) {
-        return v2 instanceof Date ? "date" : typeof v2;
-      }
+    const v2 = row[channel] ?? row[channel + "1"] ?? row[channel + "2"];
+    if (v2 != null) {
+      return v2 instanceof Date ? "date" : typeof v2;
     }
   }
 }
@@ -39992,49 +40089,6 @@ function isSymbol2(value) {
   return symbols2.has(`${value}`.toLowerCase());
 }
 
-// src/marks/util/arrow.js
-var INTEGER = 2;
-var FLOAT = 3;
-var DECIMAL = 7;
-var TIMESTAMP = 10;
-function isArrowTable(values2) {
-  return typeof values2?.getChild === "function";
-}
-function convertArrowType(type2) {
-  switch (type2.typeId) {
-    case INTEGER:
-    case FLOAT:
-    case DECIMAL:
-      return Float64Array;
-    default:
-      return Array;
-  }
-}
-function convertArrow(type2) {
-  const { typeId } = type2;
-  if (typeId === TIMESTAMP) {
-    return (v2) => v2 == null ? v2 : new Date(v2);
-  }
-  if (typeId === INTEGER && type2.bitWidth >= 64) {
-    return (v2) => v2 == null ? v2 : Number(v2);
-  }
-  return (v2) => v2;
-}
-function convertArrowColumn(column3) {
-  const { type: type2 } = column3;
-  const { typeId } = type2;
-  if (typeId === INTEGER && type2.bitWidth >= 64) {
-    const size = column3.length;
-    const array3 = new Float64Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v2 = column3.get(row);
-      array3[row] = v2 == null ? NaN : Number(v2);
-    }
-    return array3;
-  }
-  return column3.toArray();
-}
-
 // src/marks/util/to-data-array.js
 function toDataArray(data) {
   return isArrowTable(data) ? arrowToObjects(data) : data;
@@ -40050,7 +40104,7 @@ function arrowToObjects(data) {
     for (let j = 0; j < numCols; ++j) {
       const child = batch.getChildAt(j);
       const { name, type: type2 } = schema.fields[j];
-      const valueOf = convertArrow(type2);
+      const valueOf = convertArrowValue(type2);
       for (let o = k2, i = 0; i < numRows; ++i, ++o) {
         objects[o][name] = valueOf(child.get(i));
       }
@@ -40135,17 +40189,15 @@ var Mark2 = class extends MosaicClient {
   hasOwnData() {
     return this.source == null || isDataArray(this.source);
   }
+  hasFieldInfo() {
+    return !!this._fieldInfo;
+  }
   channel(channel) {
     return this.channels.find((c4) => c4.channel === channel);
   }
-  channelField(...channels) {
-    const list = channels.flat();
-    for (const channel of list) {
-      const c4 = this.channel(channel);
-      if (c4?.field)
-        return c4;
-    }
-    return null;
+  channelField(channel, { exact } = {}) {
+    const c4 = exact ? this.channel(channel) : this.channels.find((c5) => c5.channel.startsWith(channel));
+    return c4?.field ? c4 : null;
   }
   fields() {
     if (this.hasOwnData())
@@ -40153,26 +40205,25 @@ var Mark2 = class extends MosaicClient {
     const { source: { table }, channels, reqs } = this;
     const fields = /* @__PURE__ */ new Map();
     for (const { channel, field: field2 } of channels) {
-      const column3 = field2?.column;
-      if (!column3) {
+      if (!field2)
         continue;
-      } else if (field2.stats?.length || reqs[channel]) {
-        if (!fields.has(column3))
-          fields.set(column3, /* @__PURE__ */ new Set());
-        const entry = fields.get(column3);
-        reqs[channel]?.forEach((s2) => entry.add(s2));
-        field2.stats?.forEach((s2) => entry.add(s2));
-      }
+      const stats = field2.stats?.stats || [];
+      const key = field2.stats?.column ?? field2;
+      const entry = fields.get(key) ?? fields.set(key, /* @__PURE__ */ new Set()).get(key);
+      stats.forEach((s2) => entry.add(s2));
+      reqs[channel]?.forEach((s2) => entry.add(s2));
     }
-    return Array.from(fields, ([column3, stats]) => {
-      return { table, column: column3, stats: Array.from(stats) };
-    });
+    return Array.from(fields, ([c4, s2]) => ({ table, column: c4, stats: s2 }));
   }
   fieldInfo(info) {
-    this.stats = info.reduce(
-      (o, d) => (o[d.column] = d, o),
-      /* @__PURE__ */ Object.create(null)
-    );
+    const lookup = Object.fromEntries(info.map((x3) => [x3.column, x3]));
+    for (const entry of this.channels) {
+      const { field: field2 } = entry;
+      if (field2) {
+        Object.assign(entry, lookup[field2.stats?.column ?? field2]);
+      }
+    }
+    this._fieldInfo = true;
     return this;
   }
   query(filter3 = []) {
@@ -40240,8 +40291,7 @@ function channelScale(mark, channel) {
   const { plot: plot2 } = mark;
   let scaleType = plot2.getAttribute(`${channel}Scale`);
   if (!scaleType) {
-    const { field: field2 } = mark.channelField(channel, `${channel}1`, `${channel}2`);
-    const { type: type2 } = mark.stats[field2.column];
+    const { type: type2 } = mark.channelField(channel);
     scaleType = type2 === "date" ? "time" : "linear";
   }
   const options = { type: scaleType };
@@ -40279,15 +40329,13 @@ var xext = { x: ["min", "max"] };
 var yext = { y: ["min", "max"] };
 var xyext = { ...xext, ...yext };
 function plotExtent(mark, filter3, channel, domainAttr, niceAttr) {
-  const { plot: plot2, stats } = mark;
+  const { plot: plot2 } = mark;
   const domain = plot2.getAttribute(domainAttr);
   const nice3 = plot2.getAttribute(niceAttr);
   if (Array.isArray(domain) && !domain[Transient]) {
     return domain;
   } else {
-    const { field: field2 } = mark.channelField(channel);
-    const { column: column3 } = field2;
-    const { min: min5, max: max4 } = stats[column3];
+    const { column: column3, min: min5, max: max4 } = mark.channelField(channel);
     const dom = filteredExtent(filter3, column3) || (nice3 ? linear2().domain([min5, max4]).nice().domain() : [min5, max4]);
     if (domain !== Fixed)
       dom[Transient] = true;
@@ -40307,7 +40355,7 @@ function filteredExtent(filter3, column3) {
   let lo;
   let hi;
   const visitor = (type2, clause) => {
-    if (type2 === "BETWEEN" && clause.field.column === column3) {
+    if (type2 === "BETWEEN" && `${clause.field}` === column3) {
       const { range: range3 } = clause;
       if (range3 && (lo == null || range3[0] < lo))
         lo = range3[0];
@@ -40327,26 +40375,23 @@ function filteredExtent(filter3, column3) {
 var ConnectedMark = class extends Mark2 {
   constructor(type2, source, encodings) {
     const dim = type2.endsWith("X") ? "y" : type2.endsWith("Y") ? "x" : null;
-    const req = { [dim]: ["min", "max"] };
+    const req = dim ? { [dim]: ["min", "max"] } : void 0;
     super(type2, source, encodings, req);
     this.dim = dim;
   }
   query(filter3 = []) {
-    const { plot: plot2, dim, source, stats } = this;
+    const { plot: plot2, dim, source } = this;
     const { optimize = true } = source.options || {};
     const q = super.query(filter3);
     if (!dim)
       return q;
     const ortho = dim === "x" ? "y" : "x";
-    const value = this.channelField(ortho)?.as;
-    const { field: field2, as } = this.channelField(dim);
-    const { type: type2 } = stats[field2.column];
+    const value = this.channelField(ortho, { exact: true })?.as;
+    const { field: field2, as, type: type2, min: min5, max: max4 } = this.channelField(dim);
     const isContinuous = type2 === "date" || type2 === "number";
     if (optimize && isContinuous && value) {
-      const { column: column3 } = field2;
-      const { max: max4, min: min5 } = stats[column3];
       const size = dim === "x" ? plot2.innerWidth() : plot2.innerHeight();
-      const [lo, hi] = filteredExtent(filter3, column3) || [min5, max4];
+      const [lo, hi] = filteredExtent(filter3, field2) || [min5, max4];
       const [expr] = binExpr(this, dim, size, [lo, hi], 1, as);
       const cols = q.select().map((c4) => c4.as).filter((c4) => c4 !== as && c4 !== value);
       return m4(q, expr, as, value, cols);
@@ -40368,17 +40413,10 @@ function m4(input, bin3, x3, y3, cols = []) {
 
 // src/marks/util/grid.js
 function arrayType(values2, name = "density") {
-  if (isArrowTable(values2)) {
-    return convertArrowType(values2.getChild(name).type);
-  } else {
-    return typeof values2[0][name] === "number" ? Float64Array : Array;
-  }
-}
-function grid1d(n, values2) {
-  const Type3 = arrayType(values2);
-  return valuesToGrid(new Type3(n), values2);
+  return isArrowTable(values2) ? convertArrowArrayType(values2.getChild(name).type) : typeof values2[0]?.[name] === "number" ? Float64Array : Array;
 }
-function valuesToGrid(grid, values2, name = "density") {
+function grid1d(n, values2, name = "density") {
+  const grid = new (arrayType(values2))(n);
   if (isArrowTable(values2)) {
     const numRows = values2.numRows;
     if (numRows === 0)
@@ -40877,7 +40915,7 @@ var Grid2DMark = class extends Mark2 {
   }
   setPlot(plot2, index2) {
     const update2 = () => {
-      if (this.stats)
+      if (this.hasFieldInfo())
         this.requestUpdate();
     };
     plot2.addAttributeListener("domainX", update2);
@@ -41222,7 +41260,7 @@ var RasterMark = class extends Grid2DMark {
   }
   setPlot(plot2, index2) {
     const update2 = () => {
-      if (this.stats)
+      if (this.hasFieldInfo())
         this.rasterize();
     };
     plot2.addAttributeListener("schemeColor", update2);
@@ -41423,9 +41461,12 @@ var DenseLineMark = class extends RasterMark {
 function stripXY(mark, filter3) {
   if (Array.isArray(filter3) && !filter3.length)
     return filter3;
-  const xc = mark.channelField("x").field.column;
-  const yc = mark.channelField("y").field.column;
-  const test = (p) => p.op !== "BETWEEN" || p.field.column !== xc && p.field.column !== yc;
+  const { column: xc } = mark.channelField("x");
+  const { column: yc } = mark.channelField("y");
+  const test = (p) => {
+    const col = `${p.field}`;
+    return p.op !== "BETWEEN" || col !== xc && col !== yc;
+  };
   const filterAnd = (p) => p.op === "AND" ? and(p.children.filter((c4) => test(c4))) : p;
   return Array.isArray(filter3) ? filter3.filter((p) => test(p)).map((p) => filterAnd(p)) : filterAnd(filter3);
 }
@@ -41714,7 +41755,7 @@ var RasterTileMark = class extends Grid2DMark {
   }
   setPlot(plot2, index2) {
     const update2 = () => {
-      if (this.stats)
+      if (this.hasFieldInfo())
         this.rasterize();
     };
     plot2.addAttributeListener("schemeColor", update2);
@@ -42263,8 +42304,8 @@ function closeTo(a2, b) {
 }
 
 // src/interactors/util/get-field.js
-function getField(mark, channels) {
-  const field2 = mark.channelField(channels)?.field;
+function getField(mark, channel) {
+  const field2 = mark.channelField(channel)?.field;
   return field2?.basis || field2;
 }
 
@@ -42298,7 +42339,7 @@ var Interval1D = class {
     this.pixelSize = pixelSize || 1;
     this.selection = selection2;
     this.peers = peers;
-    this.field = field2 || getField(mark, [channel, channel + "1", channel + "2"]);
+    this.field = field2 || getField(mark, channel);
     this.style = style && sanitizeStyles(style);
     this.brush = channel === "y" ? brushY2() : brushX2();
     this.brush.on("brush end", ({ selection: selection3 }) => this.publish(selection3));
@@ -42366,8 +42407,8 @@ var Interval2D = class {
     this.pixelSize = pixelSize || 1;
     this.selection = selection2;
     this.peers = peers;
-    this.xfield = xfield || getField(mark, ["x", "x1", "x2"]);
-    this.yfield = yfield || getField(mark, ["y", "y1", "y2"]);
+    this.xfield = xfield || getField(mark, "x");
+    this.yfield = yfield || getField(mark, "y");
     this.style = style && sanitizeStyles(style);
     this.brush = brush2();
     this.brush.on("brush end", ({ selection: selection3 }) => this.publish(selection3));
@@ -42503,8 +42544,8 @@ var PanZoom = class {
     this.mark = mark;
     this.xsel = x3;
     this.ysel = y3;
-    this.xfield = xfield || getField(mark, ["x", "x1", "x2"]);
-    this.yfield = yfield || getField(mark, ["y", "y1", "y2"]);
+    this.xfield = xfield || getField(mark, "x");
+    this.yfield = yfield || getField(mark, "y");
     this.zoom = extent3(zoom, [0, Infinity], [1, 1]);
     this.panx = this.xsel && panx;
     this.pany = this.ysel && pany;
@@ -42733,8 +42774,10 @@ function findMark({ marks: marks2 }, channel) {
   if (channels == null)
     return null;
   for (let i = marks2.length - 1; i > -1; --i) {
-    if (marks2[i].channelField(channels)) {
-      return marks2[i];
+    for (const channel2 of channels) {
+      if (marks2[i].channelField(channel2, { exact: true })) {
+        return marks2[i];
+      }
     }
   }
   return null;
@@ -42763,7 +42806,7 @@ function binField(mark, channel, column3, options) {
     column: column3,
     label: column3,
     get stats() {
-      return ["min", "max"];
+      return { column: column3, stats: ["min", "max"] };
     },
     get columns() {
       return [column3];
@@ -42773,7 +42816,7 @@ function binField(mark, channel, column3, options) {
     },
     toString() {
       const { apply: apply2, sqlApply, sqlInvert } = channelScale(mark, channel);
-      const { min: min5, max: max4 } = mark.stats[column3];
+      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})`;