@uwdata/mosaic-plot 0.6.1 → 0.7.1

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] * 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;
@@ -25871,6 +25954,9 @@ var Accent_default = colors_default("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b176
 // ../../node_modules/d3-scale-chromatic/src/categorical/Dark2.js
 var Dark2_default = colors_default("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");
 
+// ../../node_modules/d3-scale-chromatic/src/categorical/observable10.js
+var observable10_default = colors_default("4269d0efb118ff725c6cc5b03ca951ff8ab7a463f297bbf59c6b4e9498a0");
+
 // ../../node_modules/d3-scale-chromatic/src/categorical/Paired.js
 var Paired_default = colors_default("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");
 
@@ -28081,6 +28167,15 @@ function parse(string2, fallback) {
   return new Date(string2);
 }
 
+// ../../node_modules/@observablehq/plot/src/order.js
+function orderof(values2) {
+  if (values2 == null)
+    return;
+  const first3 = values2[0];
+  const last2 = values2[values2.length - 1];
+  return descending(first3, last2);
+}
+
 // ../../node_modules/@observablehq/plot/src/time.js
 var durationSecond2 = 1e3;
 var durationMinute2 = durationSecond2 * 60;
@@ -28674,13 +28769,6 @@ function maybeAnchor(value, name) {
 function maybeFrameAnchor(value = "middle") {
   return maybeAnchor(value, "frameAnchor");
 }
-function orderof(values2) {
-  if (values2 == null)
-    return;
-  const first3 = values2[0];
-  const last2 = values2[values2.length - 1];
-  return descending(first3, last2);
-}
 function inherit2(options = {}, ...rest) {
   let o = options;
   for (const defaults23 of rest) {
@@ -28717,6 +28805,15 @@ function named2(things) {
 function maybeNamed(things) {
   return isIterable2(things) ? named2(things) : things;
 }
+function maybeClip(clip) {
+  if (clip === true)
+    clip = "frame";
+  else if (clip === false)
+    clip = null;
+  else if (clip != null)
+    clip = keyword(clip, "clip", ["frame", "sphere"]);
+  return clip;
+}
 
 // ../../node_modules/@observablehq/plot/src/scales/index.js
 var position = Symbol("position");
@@ -29036,6 +29133,8 @@ function groupn(x3, y3, {
                 extent4.x = x4;
               if (Y3)
                 extent4.y = y4;
+              if (G)
+                extent4.z = f;
               if (filter3 && !filter3.reduce(g, extent4))
                 continue;
               groupFacet.push(i++);
@@ -29134,10 +29233,7 @@ function maybeEvaluator(name, reduce, inputs, asReduce = maybeReduce) {
   };
 }
 function maybeGroup(I, X3) {
-  return X3 ? sort(
-    group(I, (i) => X3[i]),
-    first2
-  ) : [[, I]];
+  return X3 ? group(I, (i) => X3[i]) : [[, I]];
 }
 function maybeReduce(reduce, value, fallback = invalidReduce) {
   if (reduce == null)
@@ -29209,6 +29305,8 @@ function maybeGroupReduceFallback(reduce) {
       return reduceX;
     case "y":
       return reduceY;
+    case "z":
+      return reduceZ;
   }
   throw new Error(`invalid group reduce: ${reduce}`);
 }
@@ -29319,6 +29417,11 @@ var reduceY = {
     return y3;
   }
 };
+var reduceZ = {
+  reduceIndex(I, X3, { z }) {
+    return z;
+  }
+};
 function find2(test) {
   if (typeof test !== "function")
     throw new Error(`invalid test function: ${test}`);
@@ -29495,48 +29598,14 @@ function getSource(channels, key) {
   return channel.source === null ? null : channel;
 }
 
-// ../../node_modules/@observablehq/plot/src/memoize.js
-function memoize1(compute) {
-  let cacheValue, cacheKeys;
-  return (...keys) => {
-    if (cacheKeys?.length !== keys.length || cacheKeys.some((k2, i) => k2 !== keys[i])) {
-      cacheKeys = keys;
-      cacheValue = compute(...keys);
-    }
-    return cacheValue;
-  };
-}
-
-// ../../node_modules/@observablehq/plot/src/format.js
-var numberFormat = memoize1((locale3) => {
-  return new Intl.NumberFormat(locale3);
-});
-var monthFormat = memoize1((locale3, month) => {
-  return new Intl.DateTimeFormat(locale3, { timeZone: "UTC", ...month && { month } });
-});
-var weekdayFormat = memoize1((locale3, weekday) => {
-  return new Intl.DateTimeFormat(locale3, { timeZone: "UTC", ...weekday && { weekday } });
-});
-function formatNumber(locale3 = "en-US") {
-  const format3 = numberFormat(locale3);
-  return (i) => i != null && !isNaN(i) ? format3.format(i) : void 0;
-}
-function formatMonth(locale3 = "en-US", format3 = "short") {
-  const fmt = monthFormat(locale3, format3);
-  return (i) => i != null && !isNaN(i = +new Date(Date.UTC(2e3, +i))) ? fmt.format(i) : void 0;
-}
-function formatWeekday(locale3 = "en-US", format3 = "short") {
-  const fmt = weekdayFormat(locale3, format3);
-  return (i) => i != null && !isNaN(i = +new Date(Date.UTC(2001, 0, +i))) ? fmt.format(i) : void 0;
-}
-function formatIsoDate(date2) {
-  return format2(date2, "Invalid Date");
+// ../../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 formatAuto(locale3 = "en-US") {
-  const number7 = formatNumber(locale3);
-  return (v2) => (v2 instanceof Date ? formatIsoDate : typeof v2 === "number" ? number7 : string)(v2);
+function create3(name, { document: document2 }) {
+  return select_default2(creator_default(name).call(document2.documentElement));
 }
-var formatDefault = formatAuto();
 
 // ../../node_modules/@observablehq/plot/src/warnings.js
 var warnings = 0;
@@ -29555,1787 +29624,1800 @@ function warn(message) {
   ++warnings;
 }
 
-// ../../node_modules/@observablehq/plot/src/style.js
-var offset = (typeof window !== "undefined" ? window.devicePixelRatio > 1 : typeof it === "undefined") ? 0 : 0.5;
-var nextClipId = 0;
-function getClipId() {
-  return `plot-clip-${++nextClipId}`;
-}
-function styles(mark, {
-  title,
-  href,
-  ariaLabel: variaLabel,
-  ariaDescription,
-  ariaHidden,
-  target,
-  fill,
-  fillOpacity,
-  stroke,
-  strokeWidth,
-  strokeOpacity,
-  strokeLinejoin,
-  strokeLinecap,
-  strokeMiterlimit,
-  strokeDasharray,
-  strokeDashoffset,
-  opacity: opacity2,
-  mixBlendMode,
-  imageFilter,
-  paintOrder,
-  pointerEvents,
-  shapeRendering,
-  channels
-}, {
-  ariaLabel: cariaLabel,
-  fill: defaultFill = "currentColor",
-  fillOpacity: defaultFillOpacity,
-  stroke: defaultStroke = "none",
-  strokeOpacity: defaultStrokeOpacity,
-  strokeWidth: defaultStrokeWidth,
-  strokeLinecap: defaultStrokeLinecap,
-  strokeLinejoin: defaultStrokeLinejoin,
-  strokeMiterlimit: defaultStrokeMiterlimit,
-  paintOrder: defaultPaintOrder
-}) {
-  if (defaultFill === null) {
-    fill = null;
-    fillOpacity = null;
-  }
-  if (defaultStroke === null) {
-    stroke = null;
-    strokeOpacity = null;
-  }
-  if (isNoneish(defaultFill)) {
-    if (!isNoneish(defaultStroke) && (!isNoneish(fill) || channels?.fill))
-      defaultStroke = "none";
-  } else {
-    if (isNoneish(defaultStroke) && (!isNoneish(stroke) || channels?.stroke))
-      defaultFill = "none";
+// ../../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;
   }
-  const [vfill, cfill] = maybeColorChannel(fill, defaultFill);
-  const [vfillOpacity, cfillOpacity] = maybeNumberChannel(fillOpacity, defaultFillOpacity);
-  const [vstroke, cstroke] = maybeColorChannel(stroke, defaultStroke);
-  const [vstrokeOpacity, cstrokeOpacity] = maybeNumberChannel(strokeOpacity, defaultStrokeOpacity);
-  const [vopacity, copacity] = maybeNumberChannel(opacity2);
-  if (!isNone(cstroke)) {
-    if (strokeWidth === void 0)
-      strokeWidth = defaultStrokeWidth;
-    if (strokeLinecap === void 0)
-      strokeLinecap = defaultStrokeLinecap;
-    if (strokeLinejoin === void 0)
-      strokeLinejoin = defaultStrokeLinejoin;
-    if (strokeMiterlimit === void 0 && !isRound(strokeLinejoin))
-      strokeMiterlimit = defaultStrokeMiterlimit;
-    if (!isNone(cfill) && paintOrder === void 0)
-      paintOrder = defaultPaintOrder;
+  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.`);
+    }
   }
-  const [vstrokeWidth, cstrokeWidth] = maybeNumberChannel(strokeWidth);
-  if (defaultFill !== null) {
-    mark.fill = impliedString(cfill, "currentColor");
-    mark.fillOpacity = impliedNumber(cfillOpacity, 1);
+  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}`);
   }
-  if (defaultStroke !== null) {
-    mark.stroke = impliedString(cstroke, "none");
-    mark.strokeWidth = impliedNumber(cstrokeWidth, 1);
-    mark.strokeOpacity = impliedNumber(cstrokeOpacity, 1);
-    mark.strokeLinejoin = impliedString(strokeLinejoin, "miter");
-    mark.strokeLinecap = impliedString(strokeLinecap, "butt");
-    mark.strokeMiterlimit = impliedNumber(strokeMiterlimit, 4);
-    mark.strokeDasharray = impliedString(strokeDasharray, "none");
-    mark.strokeDashoffset = impliedString(strokeDashoffset, "0");
+}
+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}`);
   }
-  mark.target = string(target);
-  mark.ariaLabel = string(cariaLabel);
-  mark.ariaDescription = string(ariaDescription);
-  mark.ariaHidden = string(ariaHidden);
-  mark.opacity = impliedNumber(copacity, 1);
-  mark.mixBlendMode = impliedString(mixBlendMode, "normal");
-  mark.imageFilter = impliedString(imageFilter, "none");
-  mark.paintOrder = impliedString(paintOrder, "normal");
-  mark.pointerEvents = impliedString(pointerEvents, "auto");
-  mark.shapeRendering = impliedString(shapeRendering, "auto");
-  return {
-    title: { value: title, optional: true, filter: null },
-    href: { value: href, optional: true, filter: null },
-    ariaLabel: { value: variaLabel, optional: true, filter: null },
-    fill: { value: vfill, scale: "auto", optional: true },
-    fillOpacity: { value: vfillOpacity, scale: "auto", optional: true },
-    stroke: { value: vstroke, scale: "auto", optional: true },
-    strokeOpacity: { value: vstrokeOpacity, scale: "auto", optional: true },
-    strokeWidth: { value: vstrokeWidth, optional: true },
-    opacity: { value: vopacity, scale: "auto", optional: true }
-  };
 }
-function applyTitle(selection2, L) {
-  if (L)
-    selection2.filter((i) => nonempty(L[i])).append("title").call(applyText, L);
-}
-function applyTitleGroup(selection2, L) {
-  if (L)
-    selection2.filter(([i]) => nonempty(L[i])).append("title").call(applyTextGroup, L);
-}
-function applyText(selection2, T) {
-  if (T)
-    selection2.text((i) => formatDefault(T[i]));
-}
-function applyTextGroup(selection2, T) {
-  if (T)
-    selection2.text(([i]) => formatDefault(T[i]));
-}
-function applyChannelStyles(selection2, { target, tip: tip2 }, {
-  ariaLabel: AL,
-  title: T,
-  fill: F,
-  fillOpacity: FO,
-  stroke: S,
-  strokeOpacity: SO,
-  strokeWidth: SW,
-  opacity: O,
-  href: H
-}) {
-  if (AL)
-    applyAttr(selection2, "aria-label", (i) => AL[i]);
-  if (F)
-    applyAttr(selection2, "fill", (i) => F[i]);
-  if (FO)
-    applyAttr(selection2, "fill-opacity", (i) => FO[i]);
-  if (S)
-    applyAttr(selection2, "stroke", (i) => S[i]);
-  if (SO)
-    applyAttr(selection2, "stroke-opacity", (i) => SO[i]);
-  if (SW)
-    applyAttr(selection2, "stroke-width", (i) => SW[i]);
-  if (O)
-    applyAttr(selection2, "opacity", (i) => O[i]);
-  if (H)
-    applyHref(selection2, (i) => H[i], target);
-  if (!tip2)
-    applyTitle(selection2, T);
-}
-function applyGroupedChannelStyles(selection2, { target, tip: tip2 }, {
-  ariaLabel: AL,
-  title: T,
-  fill: F,
-  fillOpacity: FO,
-  stroke: S,
-  strokeOpacity: SO,
-  strokeWidth: SW,
-  opacity: O,
-  href: H
-}) {
-  if (AL)
-    applyAttr(selection2, "aria-label", ([i]) => AL[i]);
-  if (F)
-    applyAttr(selection2, "fill", ([i]) => F[i]);
-  if (FO)
-    applyAttr(selection2, "fill-opacity", ([i]) => FO[i]);
-  if (S)
-    applyAttr(selection2, "stroke", ([i]) => S[i]);
-  if (SO)
-    applyAttr(selection2, "stroke-opacity", ([i]) => SO[i]);
-  if (SW)
-    applyAttr(selection2, "stroke-width", ([i]) => SW[i]);
-  if (O)
-    applyAttr(selection2, "opacity", ([i]) => O[i]);
-  if (H)
-    applyHref(selection2, ([i]) => H[i], target);
-  if (!tip2)
-    applyTitleGroup(selection2, T);
-}
-function groupAesthetics({
-  ariaLabel: AL,
-  title: T,
-  fill: F,
-  fillOpacity: FO,
-  stroke: S,
-  strokeOpacity: SO,
-  strokeWidth: SW,
-  opacity: O,
-  href: H
-}, { tip: tip2 }) {
-  return [AL, tip2 ? void 0 : T, F, FO, S, SO, SW, O, H].filter((c4) => c4 !== void 0);
-}
-function groupZ2(I, Z, z) {
-  const G = group(I, (i) => Z[i]);
-  if (z === void 0 && G.size > 1 + I.length >> 1) {
-    warn(
-      `Warning: the implicit z channel has high cardinality. This may occur when the fill or stroke channel is associated with quantitative data rather than ordinal or categorical data. You can suppress this warning by setting the z option explicitly; if this data represents a single series, set z to null.`
-    );
-  }
-  return G.values();
+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* groupIndex(I, position3, mark, channels) {
-  const { z } = mark;
-  const { z: Z } = channels;
-  const A5 = groupAesthetics(channels, mark);
-  const C3 = [...position3, ...A5];
-  for (const G of Z ? groupZ2(I, Z, z) : [I]) {
-    let Ag;
-    let Gg;
-    out:
-      for (const i of G) {
-        for (const c4 of C3) {
-          if (!defined(c4[i])) {
-            if (Gg)
-              Gg.push(-1);
-            continue out;
-          }
-        }
-        if (Ag === void 0) {
-          if (Gg)
-            yield Gg;
-          Ag = A5.map((c4) => keyof2(c4[i])), Gg = [i];
-          continue;
-        }
-        Gg.push(i);
-        for (let j = 0; j < A5.length; ++j) {
-          const k2 = keyof2(A5[j][i]);
-          if (k2 !== Ag[j]) {
-            yield Gg;
-            Ag = A5.map((c4) => keyof2(c4[i])), Gg = [i];
-            continue out;
-          }
+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" });
         }
       }
-    if (Gg)
-      yield Gg;
-  }
-}
-function maybeClip(clip) {
-  if (clip === true)
-    clip = "frame";
-  else if (clip === false)
-    clip = null;
-  else if (clip != null)
-    clip = keyword(clip, "clip", ["frame", "sphere"]);
-  return clip;
+      return projection3;
+    },
+    aspectRatio
+  };
 }
-function applyClip(selection2, mark, dimensions, context) {
-  let clipUrl;
-  const { clip = context.clip } = mark;
-  switch (clip) {
-    case "frame": {
-      const { width, height, marginLeft, marginRight, marginTop, marginBottom } = dimensions;
-      const id2 = getClipId();
-      clipUrl = `url(#${id2})`;
-      selection2 = create3("svg:g", context).call(
-        (g) => g.append("svg:clipPath").attr("id", id2).append("rect").attr("x", marginLeft).attr("y", marginTop).attr("width", width - marginRight - marginLeft).attr("height", height - marginTop - marginBottom)
-      ).each(function() {
-        this.appendChild(selection2.node());
-        selection2.node = () => this;
-      });
-      break;
+var identity8 = constant({ stream: (stream) => stream });
+var reflectY = constant(
+  transform_default({
+    point(x3, y3) {
+      this.stream.point(x3, -y3);
     }
-    case "sphere": {
-      const { projection: projection3 } = context;
-      if (!projection3)
-        throw new Error(`the "sphere" clip option requires a projection`);
-      const id2 = getClipId();
-      clipUrl = `url(#${id2})`;
-      selection2.append("clipPath").attr("id", id2).append("path").attr("d", path_default(projection3)({ type: "Sphere" }));
-      break;
+  })
+);
+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]);
   }
-  applyAttr(selection2, "aria-label", mark.ariaLabel);
-  applyAttr(selection2, "aria-description", mark.ariaDescription);
-  applyAttr(selection2, "aria-hidden", mark.ariaHidden);
-  applyAttr(selection2, "clip-path", clipUrl);
 }
-function applyIndirectStyles(selection2, mark, dimensions, context) {
-  applyClip(selection2, mark, dimensions, context);
-  applyAttr(selection2, "fill", mark.fill);
-  applyAttr(selection2, "fill-opacity", mark.fillOpacity);
-  applyAttr(selection2, "stroke", mark.stroke);
-  applyAttr(selection2, "stroke-width", mark.strokeWidth);
-  applyAttr(selection2, "stroke-opacity", mark.strokeOpacity);
-  applyAttr(selection2, "stroke-linejoin", mark.strokeLinejoin);
-  applyAttr(selection2, "stroke-linecap", mark.strokeLinecap);
-  applyAttr(selection2, "stroke-miterlimit", mark.strokeMiterlimit);
-  applyAttr(selection2, "stroke-dasharray", mark.strokeDasharray);
-  applyAttr(selection2, "stroke-dashoffset", mark.strokeDashoffset);
-  applyAttr(selection2, "shape-rendering", mark.shapeRendering);
-  applyAttr(selection2, "filter", mark.imageFilter);
-  applyAttr(selection2, "paint-order", mark.paintOrder);
-  const { pointerEvents = context.pointerSticky === false ? "none" : void 0 } = mark;
-  applyAttr(selection2, "pointer-events", pointerEvents);
+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 applyDirectStyles(selection2, mark) {
-  applyStyle(selection2, "mix-blend-mode", mark.mixBlendMode);
-  applyAttr(selection2, "opacity", mark.opacity);
+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 applyHref(selection2, href, target) {
-  selection2.each(function(i) {
-    const h = href(i);
-    if (h != null) {
-      const a2 = this.ownerDocument.createElementNS(namespaces_default.svg, "a");
-      a2.setAttribute("fill", "inherit");
-      a2.setAttributeNS(namespaces_default.xlink, "href", h);
-      if (target != null)
-        a2.setAttribute("target", target);
-      this.parentNode.insertBefore(a2, this).appendChild(this);
-    }
-  });
-}
-function applyAttr(selection2, name, value) {
-  if (value != null)
-    selection2.attr(name, value);
+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 applyStyle(selection2, name, value) {
-  if (value != null)
-    selection2.style(name, value);
+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];
 }
-function applyTransform(selection2, mark, { x: x3, y: y3 }, tx = offset, ty = offset) {
-  tx += mark.dx;
-  ty += mark.dy;
-  if (x3?.bandwidth)
-    tx += x3.bandwidth() / 2;
-  if (y3?.bandwidth)
-    ty += y3.bandwidth() / 2;
-  if (tx || ty)
-    selection2.attr("transform", `translate(${tx},${ty})`);
+
+// ../../node_modules/@observablehq/plot/src/scales/schemes.js
+var categoricalSchemes = /* @__PURE__ */ new Map([
+  ["accent", Accent_default],
+  ["category10", category10_default],
+  ["dark2", Dark2_default],
+  ["observable10", observable10_default],
+  ["paired", Paired_default],
+  ["pastel1", Pastel1_default],
+  ["pastel2", Pastel2_default],
+  ["set1", Set1_default],
+  ["set2", Set2_default],
+  ["set3", Set3_default],
+  ["tableau10", Tableau10_default]
+]);
+function isCategoricalScheme(scheme28) {
+  return scheme28 != null && categoricalSchemes.has(`${scheme28}`.toLowerCase());
 }
-function impliedString(value, impliedValue) {
-  if ((value = string(value)) !== impliedValue)
-    return value;
+var ordinalSchemes = new Map([
+  ...categoricalSchemes,
+  // diverging
+  ["brbg", scheme112(scheme, BrBG_default)],
+  ["prgn", scheme112(scheme2, PRGn_default)],
+  ["piyg", scheme112(scheme3, PiYG_default)],
+  ["puor", scheme112(scheme4, PuOr_default)],
+  ["rdbu", scheme112(scheme5, RdBu_default)],
+  ["rdgy", scheme112(scheme6, RdGy_default)],
+  ["rdylbu", scheme112(scheme7, RdYlBu_default)],
+  ["rdylgn", scheme112(scheme8, RdYlGn_default)],
+  ["spectral", scheme112(scheme9, Spectral_default)],
+  // reversed diverging (for temperature data)
+  ["burd", scheme11r(scheme5, RdBu_default)],
+  ["buylrd", scheme11r(scheme7, RdYlBu_default)],
+  // sequential (single-hue)
+  ["blues", scheme92(scheme22, Blues_default)],
+  ["greens", scheme92(scheme23, Greens_default)],
+  ["greys", scheme92(scheme24, Greys_default)],
+  ["oranges", scheme92(scheme27, Oranges_default)],
+  ["purples", scheme92(scheme25, Purples_default)],
+  ["reds", scheme92(scheme26, Reds_default)],
+  // sequential (multi-hue)
+  ["turbo", schemei(turbo_default)],
+  ["viridis", schemei(viridis_default)],
+  ["magma", schemei(magma)],
+  ["inferno", schemei(inferno)],
+  ["plasma", schemei(plasma)],
+  ["cividis", schemei(cividis_default)],
+  ["cubehelix", schemei(cubehelix_default2)],
+  ["warm", schemei(warm)],
+  ["cool", schemei(cool)],
+  ["bugn", scheme92(scheme10, BuGn_default)],
+  ["bupu", scheme92(scheme11, BuPu_default)],
+  ["gnbu", scheme92(scheme12, GnBu_default)],
+  ["orrd", scheme92(scheme13, OrRd_default)],
+  ["pubu", scheme92(scheme15, PuBu_default)],
+  ["pubugn", scheme92(scheme14, PuBuGn_default)],
+  ["purd", scheme92(scheme16, PuRd_default)],
+  ["rdpu", scheme92(scheme17, RdPu_default)],
+  ["ylgn", scheme92(scheme19, YlGn_default)],
+  ["ylgnbu", scheme92(scheme18, YlGnBu_default)],
+  ["ylorbr", scheme92(scheme20, YlOrBr_default)],
+  ["ylorrd", scheme92(scheme21, YlOrRd_default)],
+  // cyclical
+  ["rainbow", schemeicyclical(rainbow_default)],
+  ["sinebow", schemeicyclical(sinebow_default)]
+]);
+function scheme92(scheme28, interpolate) {
+  return ({ length: n }) => {
+    if (n === 1)
+      return [scheme28[3][1]];
+    if (n === 2)
+      return [scheme28[3][1], scheme28[3][2]];
+    n = Math.max(3, Math.floor(n));
+    return n > 9 ? quantize_default(interpolate, n) : scheme28[n];
+  };
 }
-function impliedNumber(value, impliedValue) {
-  if ((value = number5(value)) !== impliedValue)
-    return value;
+function scheme112(scheme28, interpolate) {
+  return ({ length: n }) => {
+    if (n === 2)
+      return [scheme28[3][0], scheme28[3][2]];
+    n = Math.max(3, Math.floor(n));
+    return n > 11 ? quantize_default(interpolate, n) : scheme28[n];
+  };
 }
-var validClassName = /^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i;
-function maybeClassName(name) {
-  if (name === void 0)
-    return "plot-d6a7b5";
-  name = `${name}`;
-  if (!validClassName.test(name))
-    throw new Error(`invalid class name: ${name}`);
-  return name;
+function scheme11r(scheme28, interpolate) {
+  return ({ length: n }) => {
+    if (n === 2)
+      return [scheme28[3][2], scheme28[3][0]];
+    n = Math.max(3, Math.floor(n));
+    return n > 11 ? quantize_default((t) => interpolate(1 - t), n) : scheme28[n].slice().reverse();
+  };
 }
-function applyInlineStyles(selection2, style) {
-  if (typeof style === "string") {
-    selection2.property("style", style);
-  } else if (style != null) {
-    for (const element of selection2) {
-      Object.assign(element.style, style);
-    }
-  }
+function schemei(interpolate) {
+  return ({ length: n }) => quantize_default(interpolate, Math.max(2, Math.floor(n)));
 }
-function applyFrameAnchor({ frameAnchor }, { width, height, marginTop, marginRight, marginBottom, marginLeft }) {
-  return [
-    /left$/.test(frameAnchor) ? marginLeft : /right$/.test(frameAnchor) ? width - marginRight : (marginLeft + width - marginRight) / 2,
-    /^top/.test(frameAnchor) ? marginTop : /^bottom/.test(frameAnchor) ? height - marginBottom : (marginTop + height - marginBottom) / 2
-  ];
+function schemeicyclical(interpolate) {
+  return ({ length: n }) => quantize_default(interpolate, Math.floor(n) + 1).slice(0, -1);
 }
-
-// ../../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 ordinalScheme(scheme28) {
+  const s2 = `${scheme28}`.toLowerCase();
+  if (!ordinalSchemes.has(s2))
+    throw new Error(`unknown ordinal scheme: ${s2}`);
+  return ordinalSchemes.get(s2);
 }
-function create3(name, { document: document2 }) {
-  return select_default2(creator_default(name).call(document2.documentElement));
+function ordinalRange(scheme28, length4) {
+  const s2 = ordinalScheme(scheme28);
+  const r = typeof s2 === "function" ? s2({ length: length4 }) : s2;
+  return r.length !== length4 ? r.slice(0, length4) : r;
 }
-
-// ../../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)
+function maybeBooleanRange(domain, scheme28 = "greys") {
+  const range3 = /* @__PURE__ */ new Set();
+  const [f, t] = ordinalRange(scheme28, 2);
+  for (const value of domain) {
+    if (value == null)
+      continue;
+    if (value === true)
+      range3.add(t);
+    else if (value === false)
+      range3.add(f);
+    else
       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.`);
+  return [...range3];
+}
+var quantitativeSchemes = /* @__PURE__ */ new Map([
+  // diverging
+  ["brbg", BrBG_default],
+  ["prgn", PRGn_default],
+  ["piyg", PiYG_default],
+  ["puor", PuOr_default],
+  ["rdbu", RdBu_default],
+  ["rdgy", RdGy_default],
+  ["rdylbu", RdYlBu_default],
+  ["rdylgn", RdYlGn_default],
+  ["spectral", Spectral_default],
+  // reversed diverging (for temperature data)
+  ["burd", (t) => RdBu_default(1 - t)],
+  ["buylrd", (t) => RdYlBu_default(1 - t)],
+  // sequential (single-hue)
+  ["blues", Blues_default],
+  ["greens", Greens_default],
+  ["greys", Greys_default],
+  ["purples", Purples_default],
+  ["reds", Reds_default],
+  ["oranges", Oranges_default],
+  // sequential (multi-hue)
+  ["turbo", turbo_default],
+  ["viridis", viridis_default],
+  ["magma", magma],
+  ["inferno", inferno],
+  ["plasma", plasma],
+  ["cividis", cividis_default],
+  ["cubehelix", cubehelix_default2],
+  ["warm", warm],
+  ["cool", cool],
+  ["bugn", BuGn_default],
+  ["bupu", BuPu_default],
+  ["gnbu", GnBu_default],
+  ["orrd", OrRd_default],
+  ["pubugn", PuBuGn_default],
+  ["pubu", PuBu_default],
+  ["purd", PuRd_default],
+  ["rdpu", RdPu_default],
+  ["ylgnbu", YlGnBu_default],
+  ["ylgn", YlGn_default],
+  ["ylorbr", YlOrBr_default],
+  ["ylorrd", YlOrRd_default],
+  // cyclical
+  ["rainbow", rainbow_default],
+  ["sinebow", sinebow_default]
+]);
+function quantitativeScheme(scheme28) {
+  const s2 = `${scheme28}`.toLowerCase();
+  if (!quantitativeSchemes.has(s2))
+    throw new Error(`unknown quantitative scheme: ${s2}`);
+  return quantitativeSchemes.get(s2);
+}
+var divergingSchemes = /* @__PURE__ */ new Set([
+  "brbg",
+  "prgn",
+  "piyg",
+  "puor",
+  "rdbu",
+  "rdgy",
+  "rdylbu",
+  "rdylgn",
+  "spectral",
+  "burd",
+  "buylrd"
+]);
+function isDivergingScheme(scheme28) {
+  return scheme28 != null && divergingSchemes.has(`${scheme28}`.toLowerCase());
+}
+
+// ../../node_modules/@observablehq/plot/src/scales/quantitative.js
+var flip = (i) => (t) => i(1 - t);
+var unit2 = [0, 1];
+var interpolators = /* @__PURE__ */ new Map([
+  // numbers
+  ["number", number_default],
+  // color spaces
+  ["rgb", rgb_default],
+  ["hsl", hsl_default],
+  ["hcl", hcl_default],
+  ["lab", lab2]
+]);
+function maybeInterpolator(interpolate) {
+  const i = `${interpolate}`.toLowerCase();
+  if (!interpolators.has(i))
+    throw new Error(`unknown interpolator: ${i}`);
+  return interpolators.get(i);
+}
+function createScaleQ(key, scale3, channels, {
+  type: type2,
+  nice: nice3,
+  clamp,
+  zero: zero3,
+  domain = inferAutoDomain(key, channels),
+  unknown,
+  round: round2,
+  scheme: scheme28,
+  interval: interval2,
+  range: range3 = registry.get(key) === radius ? inferRadialRange(channels, domain) : registry.get(key) === length3 ? inferLengthRange(channels, domain) : registry.get(key) === opacity ? unit2 : void 0,
+  interpolate = registry.get(key) === color2 ? scheme28 == null && range3 !== void 0 ? rgb_default : quantitativeScheme(scheme28 !== void 0 ? scheme28 : type2 === "cyclical" ? "rainbow" : "turbo") : round2 ? round_default : number_default,
+  reverse: reverse3
+}) {
+  interval2 = maybeRangeInterval(interval2, type2);
+  if (type2 === "cyclical" || type2 === "sequential")
+    type2 = "linear";
+  if (typeof interpolate !== "function")
+    interpolate = maybeInterpolator(interpolate);
+  reverse3 = !!reverse3;
+  if (range3 !== void 0) {
+    const n = (domain = arrayify2(domain)).length;
+    const m = (range3 = arrayify2(range3)).length;
+    if (n !== m) {
+      if (interpolate.length === 1)
+        throw new Error("invalid piecewise interpolator");
+      interpolate = piecewise(interpolate, range3);
+      range3 = void 0;
     }
   }
-  transform3 ??= tx === 0 && ty === 0 ? identity8() : transform_default({
-    point(x3, y3) {
-      this.stream.point(x3 + tx, y3 + ty);
+  if (interpolate.length === 1) {
+    if (reverse3) {
+      interpolate = flip(interpolate);
+      reverse3 = false;
+    }
+    if (range3 === void 0) {
+      range3 = Float64Array.from(domain, (_, i) => i / (domain.length - 1));
+      if (range3.length === 2)
+        range3 = unit2;
+    }
+    scale3.interpolate((range3 === unit2 ? constant : interpolatePiecewise)(interpolate));
+  } else {
+    scale3.interpolate(interpolate);
+  }
+  if (zero3) {
+    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;
     }
-  });
-  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}`);
   }
+  if (reverse3)
+    domain = reverse(domain);
+  scale3.domain(domain).unknown(unknown);
+  if (nice3)
+    scale3.nice(maybeNice(nice3, type2)), domain = scale3.domain();
+  if (range3 !== void 0)
+    scale3.range(range3);
+  if (clamp)
+    scale3.clamp(clamp);
+  return { type: type2, domain, range: range3, scale: scale3, interpolate, interval: interval2 };
 }
-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 maybeNice(nice3, type2) {
+  return nice3 === true ? void 0 : typeof nice3 === "number" ? nice3 : maybeNiceInterval(nice3, type2);
+}
+function createScaleLinear(key, channels, options) {
+  return createScaleQ(key, linear2(), channels, options);
+}
+function createScaleSqrt(key, channels, options) {
+  return createScalePow(key, channels, { ...options, exponent: 0.5 });
+}
+function createScalePow(key, channels, { exponent = 1, ...options }) {
+  return createScaleQ(key, pow3().exponent(exponent), channels, { ...options, type: "pow" });
+}
+function createScaleLog(key, channels, { base = 10, domain = inferLogDomain(channels), ...options }) {
+  return createScaleQ(key, log2().base(base), channels, { ...options, domain });
+}
+function createScaleSymlog(key, channels, { constant: constant2 = 1, ...options }) {
+  return createScaleQ(key, symlog().constant(constant2), channels, options);
+}
+function createScaleQuantile(key, channels, {
+  range: range3,
+  quantiles = range3 === void 0 ? 5 : (range3 = [...range3]).length,
+  // deprecated; use n instead
+  n = quantiles,
+  scheme: scheme28 = "rdylbu",
+  domain = inferQuantileDomain(channels),
+  unknown,
+  interpolate,
+  reverse: reverse3
+}) {
+  if (range3 === void 0) {
+    range3 = interpolate !== void 0 ? quantize_default(interpolate, n) : registry.get(key) === color2 ? ordinalRange(scheme28, n) : void 0;
+  }
+  if (domain.length > 0) {
+    domain = quantile3(domain, range3 === void 0 ? { length: n } : range3).quantiles();
   }
+  return createScaleThreshold(key, channels, { domain, range: range3, reverse: reverse3, unknown });
 }
-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 createScaleQuantize(key, channels, {
+  range: range3,
+  n = range3 === void 0 ? 5 : (range3 = [...range3]).length,
+  scheme: scheme28 = "rdylbu",
+  domain = inferAutoDomain(key, channels),
+  unknown,
+  interpolate,
+  reverse: reverse3
+}) {
+  const [min5, max4] = extent(domain);
+  let thresholds;
+  if (range3 === void 0) {
+    thresholds = ticks(min5, max4, n);
+    if (thresholds[0] <= min5)
+      thresholds.splice(0, 1);
+    if (thresholds[thresholds.length - 1] >= max4)
+      thresholds.pop();
+    n = thresholds.length + 1;
+    range3 = interpolate !== void 0 ? quantize_default(interpolate, n) : registry.get(key) === color2 ? ordinalRange(scheme28, n) : void 0;
+  } else {
+    thresholds = quantize_default(number_default(min5, max4), n + 1).slice(1, -1);
+    if (min5 instanceof Date)
+      thresholds = thresholds.map((x3) => new Date(x3));
+  }
+  if (orderof(arrayify2(domain)) < 0)
+    thresholds.reverse();
+  return createScaleThreshold(key, channels, { domain: thresholds, range: range3, reverse: reverse3, unknown });
 }
-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
+function createScaleThreshold(key, channels, {
+  domain = [0],
+  // explicit thresholds in ascending order
+  unknown,
+  scheme: scheme28 = "rdylbu",
+  interpolate,
+  range: range3 = interpolate !== void 0 ? quantize_default(interpolate, domain.length + 1) : registry.get(key) === color2 ? ordinalRange(scheme28, domain.length + 1) : void 0,
+  reverse: reverse3
+}) {
+  domain = arrayify2(domain);
+  const sign3 = orderof(domain);
+  if (!isNaN(sign3) && !isOrdered(domain, sign3))
+    throw new Error(`the ${key} scale has a non-monotonic domain`);
+  if (reverse3)
+    range3 = reverse(range3);
+  return {
+    type: "threshold",
+    scale: threshold(sign3 < 0 ? reverse(domain) : domain, range3 === void 0 ? [] : range3).unknown(unknown),
+    domain,
+    range: range3
   };
 }
-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 isOrdered(domain, sign3) {
+  for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {
+    const s2 = descending(d, d = domain[i]);
+    if (s2 !== 0 && s2 !== sign3)
+      return false;
   }
+  return true;
 }
-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 createScaleIdentity(key) {
+  return { type: "identity", scale: hasNumericRange(registry.get(key)) ? identity5() : (d) => d };
 }
-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 inferDomain(channels, f = finite2) {
+  return channels.length ? [
+    min2(channels, ({ value }) => value === void 0 ? value : min2(value, f)),
+    max2(channels, ({ value }) => value === void 0 ? value : max2(value, f))
+  ] : [0, 1];
 }
-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 inferAutoDomain(key, channels) {
+  const type2 = registry.get(key);
+  return (type2 === radius || type2 === opacity || type2 === length3 ? inferZeroDomain : inferDomain)(channels);
 }
-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() {
+function inferZeroDomain(channels) {
+  return [0, channels.length ? max2(channels, ({ value }) => value === void 0 ? value : max2(value, finite2)) : 1];
+}
+function inferRadialRange(channels, domain) {
+  const hint = channels.find(({ radius: radius2 }) => radius2 !== void 0);
+  if (hint !== void 0)
+    return [0, hint.radius];
+  const h25 = quantile2(channels, 0.5, ({ value }) => value === void 0 ? NaN : quantile2(value, 0.25, positive));
+  const range3 = domain.map((d) => 3 * Math.sqrt(d / h25));
+  const k2 = 30 / max2(range3);
+  return k2 < 1 ? range3.map((r) => r * k2) : range3;
+}
+function inferLengthRange(channels, domain) {
+  const h50 = median2(channels, ({ value }) => value === void 0 ? NaN : median2(value, Math.abs));
+  const range3 = domain.map((d) => 12 * d / h50);
+  const k2 = 60 / max2(range3);
+  return k2 < 1 ? range3.map((r) => r * k2) : range3;
+}
+function inferLogDomain(channels) {
+  for (const { value } of channels) {
+    if (value !== void 0) {
+      for (let v2 of value) {
+        if (v2 > 0)
+          return inferDomain(channels, positive);
+        if (v2 < 0)
+          return inferDomain(channels, negative);
+      }
     }
-  };
-  for (const object2 of channel.value)
-    stream_default(object2, sink);
-  return [x3, y3];
+  }
+  return [1, 10];
 }
-
-// ../../node_modules/@observablehq/plot/src/scales/schemes.js
-var schemeObservable10 = [
-  "#4269d0",
-  "#efb118",
-  "#ff725c",
-  "#6cc5b0",
-  "#3ca951",
-  "#ff8ab7",
-  "#a463f2",
-  "#97bbf5",
-  "#9c6b4e",
-  "#9498a0"
-];
-var categoricalSchemes = /* @__PURE__ */ new Map([
-  ["accent", Accent_default],
-  ["category10", category10_default],
-  ["dark2", Dark2_default],
-  ["observable10", schemeObservable10],
-  ["paired", Paired_default],
-  ["pastel1", Pastel1_default],
-  ["pastel2", Pastel2_default],
-  ["set1", Set1_default],
-  ["set2", Set2_default],
-  ["set3", Set3_default],
-  ["tableau10", Tableau10_default]
-]);
-function isCategoricalScheme(scheme28) {
-  return scheme28 != null && categoricalSchemes.has(`${scheme28}`.toLowerCase());
+function inferQuantileDomain(channels) {
+  const domain = [];
+  for (const { value } of channels) {
+    if (value === void 0)
+      continue;
+    for (const v2 of value)
+      domain.push(v2);
+  }
+  return domain;
 }
-var ordinalSchemes = new Map([
-  ...categoricalSchemes,
-  // diverging
-  ["brbg", scheme112(scheme, BrBG_default)],
-  ["prgn", scheme112(scheme2, PRGn_default)],
-  ["piyg", scheme112(scheme3, PiYG_default)],
-  ["puor", scheme112(scheme4, PuOr_default)],
-  ["rdbu", scheme112(scheme5, RdBu_default)],
-  ["rdgy", scheme112(scheme6, RdGy_default)],
-  ["rdylbu", scheme112(scheme7, RdYlBu_default)],
-  ["rdylgn", scheme112(scheme8, RdYlGn_default)],
-  ["spectral", scheme112(scheme9, Spectral_default)],
-  // reversed diverging (for temperature data)
-  ["burd", scheme11r(scheme5, RdBu_default)],
-  ["buylrd", scheme11r(scheme7, RdYlBu_default)],
-  // sequential (single-hue)
-  ["blues", scheme92(scheme22, Blues_default)],
-  ["greens", scheme92(scheme23, Greens_default)],
-  ["greys", scheme92(scheme24, Greys_default)],
-  ["oranges", scheme92(scheme27, Oranges_default)],
-  ["purples", scheme92(scheme25, Purples_default)],
-  ["reds", scheme92(scheme26, Reds_default)],
-  // sequential (multi-hue)
-  ["turbo", schemei(turbo_default)],
-  ["viridis", schemei(viridis_default)],
-  ["magma", schemei(magma)],
-  ["inferno", schemei(inferno)],
-  ["plasma", schemei(plasma)],
-  ["cividis", schemei(cividis_default)],
-  ["cubehelix", schemei(cubehelix_default2)],
-  ["warm", schemei(warm)],
-  ["cool", schemei(cool)],
-  ["bugn", scheme92(scheme10, BuGn_default)],
-  ["bupu", scheme92(scheme11, BuPu_default)],
-  ["gnbu", scheme92(scheme12, GnBu_default)],
-  ["orrd", scheme92(scheme13, OrRd_default)],
-  ["pubu", scheme92(scheme15, PuBu_default)],
-  ["pubugn", scheme92(scheme14, PuBuGn_default)],
-  ["purd", scheme92(scheme16, PuRd_default)],
-  ["rdpu", scheme92(scheme17, RdPu_default)],
-  ["ylgn", scheme92(scheme19, YlGn_default)],
-  ["ylgnbu", scheme92(scheme18, YlGnBu_default)],
-  ["ylorbr", scheme92(scheme20, YlOrBr_default)],
-  ["ylorrd", scheme92(scheme21, YlOrRd_default)],
-  // cyclical
-  ["rainbow", schemeicyclical(rainbow_default)],
-  ["sinebow", schemeicyclical(sinebow_default)]
-]);
-function scheme92(scheme28, interpolate) {
-  return ({ length: n }) => {
-    if (n === 1)
-      return [scheme28[3][1]];
-    if (n === 2)
-      return [scheme28[3][1], scheme28[3][2]];
-    n = Math.max(3, Math.floor(n));
-    return n > 9 ? quantize_default(interpolate, n) : scheme28[n];
-  };
+function interpolatePiecewise(interpolate) {
+  return (i, j) => (t) => interpolate(i + t * (j - i));
 }
-function scheme112(scheme28, interpolate) {
-  return ({ length: n }) => {
-    if (n === 2)
-      return [scheme28[3][0], scheme28[3][2]];
-    n = Math.max(3, Math.floor(n));
-    return n > 11 ? quantize_default(interpolate, n) : scheme28[n];
-  };
+
+// ../../node_modules/@observablehq/plot/src/scales/diverging.js
+function createScaleD(key, scale3, transform3, channels, {
+  type: type2,
+  nice: nice3,
+  clamp,
+  domain = inferDomain(channels),
+  unknown,
+  pivot = 0,
+  scheme: scheme28,
+  range: range3,
+  symmetric = true,
+  interpolate = registry.get(key) === color2 ? scheme28 == null && range3 !== void 0 ? rgb_default : quantitativeScheme(scheme28 !== void 0 ? scheme28 : "rdbu") : number_default,
+  reverse: reverse3
+}) {
+  pivot = +pivot;
+  domain = arrayify2(domain);
+  let [min5, max4] = domain;
+  if (domain.length > 2)
+    warn(`Warning: the diverging ${key} scale domain contains extra elements.`);
+  if (descending(min5, max4) < 0)
+    [min5, max4] = [max4, min5], reverse3 = !reverse3;
+  min5 = Math.min(min5, pivot);
+  max4 = Math.max(max4, pivot);
+  if (typeof interpolate !== "function") {
+    interpolate = maybeInterpolator(interpolate);
+  }
+  if (range3 !== void 0) {
+    interpolate = interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range3) : piecewise(interpolate, range3);
+  }
+  if (reverse3)
+    interpolate = flip(interpolate);
+  if (symmetric) {
+    const mid2 = transform3.apply(pivot);
+    const mindelta = mid2 - transform3.apply(min5);
+    const maxdelta = transform3.apply(max4) - mid2;
+    if (mindelta < maxdelta)
+      min5 = transform3.invert(mid2 - maxdelta);
+    else if (mindelta > maxdelta)
+      max4 = transform3.invert(mid2 + mindelta);
+  }
+  scale3.domain([min5, pivot, max4]).unknown(unknown).interpolator(interpolate);
+  if (clamp)
+    scale3.clamp(clamp);
+  if (nice3)
+    scale3.nice(nice3);
+  return { type: type2, domain: [min5, max4], pivot, interpolate, scale: scale3 };
 }
-function scheme11r(scheme28, interpolate) {
-  return ({ length: n }) => {
-    if (n === 2)
-      return [scheme28[3][2], scheme28[3][0]];
-    n = Math.max(3, Math.floor(n));
-    return n > 11 ? quantize_default((t) => interpolate(1 - t), n) : scheme28[n].slice().reverse();
-  };
+function createScaleDiverging(key, channels, options) {
+  return createScaleD(key, diverging(), transformIdentity, channels, options);
 }
-function schemei(interpolate) {
-  return ({ length: n }) => quantize_default(interpolate, Math.max(2, Math.floor(n)));
+function createScaleDivergingSqrt(key, channels, options) {
+  return createScaleDivergingPow(key, channels, { ...options, exponent: 0.5 });
 }
-function schemeicyclical(interpolate) {
-  return ({ length: n }) => quantize_default(interpolate, Math.floor(n) + 1).slice(0, -1);
+function createScaleDivergingPow(key, channels, { exponent = 1, ...options }) {
+  return createScaleD(key, divergingPow().exponent(exponent = +exponent), transformPow2(exponent), channels, {
+    ...options,
+    type: "diverging-pow"
+  });
 }
-function ordinalScheme(scheme28) {
-  const s2 = `${scheme28}`.toLowerCase();
-  if (!ordinalSchemes.has(s2))
-    throw new Error(`unknown ordinal scheme: ${s2}`);
-  return ordinalSchemes.get(s2);
+function createScaleDivergingLog(key, channels, { base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options }) {
+  return createScaleD(key, divergingLog().base(base = +base), transformLog2, channels, {
+    domain,
+    pivot,
+    ...options
+  });
 }
-function ordinalRange(scheme28, length4) {
-  const s2 = ordinalScheme(scheme28);
-  const r = typeof s2 === "function" ? s2({ length: length4 }) : s2;
-  return r.length !== length4 ? r.slice(0, length4) : r;
+function createScaleDivergingSymlog(key, channels, { constant: constant2 = 1, ...options }) {
+  return createScaleD(
+    key,
+    divergingSymlog().constant(constant2 = +constant2),
+    transformSymlog2(constant2),
+    channels,
+    options
+  );
 }
-function maybeBooleanRange(domain, scheme28 = "greys") {
-  const range3 = /* @__PURE__ */ new Set();
-  const [f, t] = ordinalRange(scheme28, 2);
-  for (const value of domain) {
-    if (value == null)
-      continue;
-    if (value === true)
-      range3.add(t);
-    else if (value === false)
-      range3.add(f);
-    else
-      return;
+var transformIdentity = {
+  apply(x3) {
+    return x3;
+  },
+  invert(x3) {
+    return x3;
   }
-  return [...range3];
-}
-var quantitativeSchemes = /* @__PURE__ */ new Map([
-  // diverging
-  ["brbg", BrBG_default],
-  ["prgn", PRGn_default],
-  ["piyg", PiYG_default],
-  ["puor", PuOr_default],
-  ["rdbu", RdBu_default],
-  ["rdgy", RdGy_default],
-  ["rdylbu", RdYlBu_default],
-  ["rdylgn", RdYlGn_default],
-  ["spectral", Spectral_default],
-  // reversed diverging (for temperature data)
-  ["burd", (t) => RdBu_default(1 - t)],
-  ["buylrd", (t) => RdYlBu_default(1 - t)],
-  // sequential (single-hue)
-  ["blues", Blues_default],
-  ["greens", Greens_default],
-  ["greys", Greys_default],
-  ["purples", Purples_default],
-  ["reds", Reds_default],
-  ["oranges", Oranges_default],
-  // sequential (multi-hue)
-  ["turbo", turbo_default],
-  ["viridis", viridis_default],
-  ["magma", magma],
-  ["inferno", inferno],
-  ["plasma", plasma],
-  ["cividis", cividis_default],
-  ["cubehelix", cubehelix_default2],
-  ["warm", warm],
-  ["cool", cool],
-  ["bugn", BuGn_default],
-  ["bupu", BuPu_default],
-  ["gnbu", GnBu_default],
-  ["orrd", OrRd_default],
-  ["pubugn", PuBuGn_default],
-  ["pubu", PuBu_default],
-  ["purd", PuRd_default],
-  ["rdpu", RdPu_default],
-  ["ylgnbu", YlGnBu_default],
-  ["ylgn", YlGn_default],
-  ["ylorbr", YlOrBr_default],
-  ["ylorrd", YlOrRd_default],
-  // cyclical
-  ["rainbow", rainbow_default],
-  ["sinebow", sinebow_default]
-]);
-function quantitativeScheme(scheme28) {
-  const s2 = `${scheme28}`.toLowerCase();
-  if (!quantitativeSchemes.has(s2))
-    throw new Error(`unknown quantitative scheme: ${s2}`);
-  return quantitativeSchemes.get(s2);
+};
+var transformLog2 = {
+  apply: Math.log,
+  invert: Math.exp
+};
+var transformSqrt2 = {
+  apply(x3) {
+    return Math.sign(x3) * Math.sqrt(Math.abs(x3));
+  },
+  invert(x3) {
+    return Math.sign(x3) * (x3 * x3);
+  }
+};
+function transformPow2(exponent) {
+  return exponent === 0.5 ? transformSqrt2 : {
+    apply(x3) {
+      return Math.sign(x3) * Math.pow(Math.abs(x3), exponent);
+    },
+    invert(x3) {
+      return Math.sign(x3) * Math.pow(Math.abs(x3), 1 / exponent);
+    }
+  };
 }
-var divergingSchemes = /* @__PURE__ */ new Set([
-  "brbg",
-  "prgn",
-  "piyg",
-  "puor",
-  "rdbu",
-  "rdgy",
-  "rdylbu",
-  "rdylgn",
-  "spectral",
-  "burd",
-  "buylrd"
-]);
-function isDivergingScheme(scheme28) {
-  return scheme28 != null && divergingSchemes.has(`${scheme28}`.toLowerCase());
+function transformSymlog2(constant2) {
+  return {
+    apply(x3) {
+      return Math.sign(x3) * Math.log1p(Math.abs(x3 / constant2));
+    },
+    invert(x3) {
+      return Math.sign(x3) * Math.expm1(Math.abs(x3)) * constant2;
+    }
+  };
 }
 
-// ../../node_modules/@observablehq/plot/src/scales/quantitative.js
-var flip = (i) => (t) => i(1 - t);
-var unit2 = [0, 1];
-var interpolators = /* @__PURE__ */ new Map([
-  // numbers
-  ["number", number_default],
-  // color spaces
-  ["rgb", rgb_default],
-  ["hsl", hsl_default],
-  ["hcl", hcl_default],
-  ["lab", lab2]
-]);
-function maybeInterpolator(interpolate) {
-  const i = `${interpolate}`.toLowerCase();
-  if (!interpolators.has(i))
-    throw new Error(`unknown interpolator: ${i}`);
-  return interpolators.get(i);
+// ../../node_modules/@observablehq/plot/src/scales/temporal.js
+function createScaleT(key, scale3, channels, options) {
+  return createScaleQ(key, scale3, channels, options);
 }
-function createScaleQ(key, scale3, channels, {
-  type: type2,
-  nice: nice3,
-  clamp,
-  zero: zero3,
-  domain = inferAutoDomain(key, channels),
-  unknown,
-  round: round2,
-  scheme: scheme28,
-  interval: interval2,
-  range: range3 = registry.get(key) === radius ? inferRadialRange(channels, domain) : registry.get(key) === length3 ? inferLengthRange(channels, domain) : registry.get(key) === opacity ? unit2 : void 0,
-  interpolate = registry.get(key) === color2 ? scheme28 == null && range3 !== void 0 ? rgb_default : quantitativeScheme(scheme28 !== void 0 ? scheme28 : type2 === "cyclical" ? "rainbow" : "turbo") : round2 ? round_default : number_default,
-  reverse: reverse3
-}) {
+function createScaleTime(key, channels, options) {
+  return createScaleT(key, time(), channels, options);
+}
+function createScaleUtc(key, channels, options) {
+  return createScaleT(key, utcTime(), channels, options);
+}
+
+// ../../node_modules/@observablehq/plot/src/scales/ordinal.js
+var ordinalImplicit = Symbol("ordinal");
+function createScaleO(key, scale3, channels, { type: type2, interval: interval2, domain, range: range3, reverse: reverse3, hint }) {
   interval2 = maybeRangeInterval(interval2, type2);
-  if (type2 === "cyclical" || type2 === "sequential")
-    type2 = "linear";
-  if (typeof interpolate !== "function")
-    interpolate = maybeInterpolator(interpolate);
-  reverse3 = !!reverse3;
+  if (domain === void 0)
+    domain = inferDomain2(channels, interval2, key);
+  if (type2 === "categorical" || type2 === ordinalImplicit)
+    type2 = "ordinal";
+  if (reverse3)
+    domain = reverse(domain);
+  domain = scale3.domain(domain).domain();
   if (range3 !== void 0) {
-    const n = (domain = arrayify2(domain)).length;
-    const m = (range3 = arrayify2(range3)).length;
-    if (n !== m) {
-      if (interpolate.length === 1)
-        throw new Error("invalid piecewise interpolator");
-      interpolate = piecewise(interpolate, range3);
-      range3 = void 0;
+    if (typeof range3 === "function")
+      range3 = range3(domain);
+    scale3.range(range3);
+  }
+  return { type: type2, domain, range: range3, scale: scale3, hint, interval: interval2 };
+}
+function createScaleOrdinal(key, channels, { type: type2, interval: interval2, domain, range: range3, scheme: scheme28, unknown, ...options }) {
+  interval2 = maybeRangeInterval(interval2, type2);
+  if (domain === void 0)
+    domain = inferDomain2(channels, interval2, key);
+  let hint;
+  if (registry.get(key) === symbol) {
+    hint = inferSymbolHint(channels);
+    range3 = range3 === void 0 ? inferSymbolRange(hint) : map2(range3, maybeSymbol);
+  } else if (registry.get(key) === color2) {
+    if (range3 === void 0 && (type2 === "ordinal" || type2 === ordinalImplicit)) {
+      range3 = maybeBooleanRange(domain, scheme28);
+      if (range3 !== void 0)
+        scheme28 = void 0;
     }
-  }
-  if (interpolate.length === 1) {
-    if (reverse3) {
-      interpolate = flip(interpolate);
-      reverse3 = false;
+    if (scheme28 === void 0 && range3 === void 0) {
+      scheme28 = type2 === "ordinal" ? "turbo" : "observable10";
     }
-    if (range3 === void 0) {
-      range3 = Float64Array.from(domain, (_, i) => i / (domain.length - 1));
-      if (range3.length === 2)
-        range3 = unit2;
+    if (scheme28 !== void 0) {
+      if (range3 !== void 0) {
+        const interpolate = quantitativeScheme(scheme28);
+        const t03 = range3[0], d = range3[1] - range3[0];
+        range3 = ({ length: n }) => quantize_default((t) => interpolate(t03 + d * t), n);
+      } else {
+        range3 = ordinalScheme(scheme28);
+      }
     }
-    scale3.interpolate((range3 === unit2 ? constant : interpolatePiecewise)(interpolate));
-  } else {
-    scale3.interpolate(interpolate);
   }
-  if (zero3) {
-    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;
-    }
+  if (unknown === implicit) {
+    throw new Error(`implicit unknown on ${key} scale is not supported`);
   }
-  if (reverse3)
-    domain = reverse(domain);
-  scale3.domain(domain).unknown(unknown);
-  if (nice3)
-    scale3.nice(maybeNice(nice3, type2)), domain = scale3.domain();
-  if (range3 !== void 0)
-    scale3.range(range3);
-  if (clamp)
-    scale3.clamp(clamp);
-  return { type: type2, domain, range: range3, scale: scale3, interpolate, interval: interval2 };
-}
-function maybeNice(nice3, type2) {
-  return nice3 === true ? void 0 : typeof nice3 === "number" ? nice3 : maybeNiceInterval(nice3, type2);
-}
-function createScaleLinear(key, channels, options) {
-  return createScaleQ(key, linear2(), channels, options);
-}
-function createScaleSqrt(key, channels, options) {
-  return createScalePow(key, channels, { ...options, exponent: 0.5 });
+  return createScaleO(key, ordinal().unknown(unknown), channels, { ...options, type: type2, domain, range: range3, hint });
 }
-function createScalePow(key, channels, { exponent = 1, ...options }) {
-  return createScaleQ(key, pow3().exponent(exponent), channels, { ...options, type: "pow" });
+function createScalePoint(key, channels, { align = 0.5, padding = 0.5, ...options }) {
+  return maybeRound(point().align(align).padding(padding), channels, options, key);
 }
-function createScaleLog(key, channels, { base = 10, domain = inferLogDomain(channels), ...options }) {
-  return createScaleQ(key, log2().base(base), channels, { ...options, domain });
+function createScaleBand(key, channels, {
+  align = 0.5,
+  padding = 0.1,
+  paddingInner = padding,
+  paddingOuter = key === "fx" || key === "fy" ? 0 : padding,
+  ...options
+}) {
+  return maybeRound(
+    band().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),
+    channels,
+    options,
+    key
+  );
 }
-function createScaleSymlog(key, channels, { constant: constant2 = 1, ...options }) {
-  return createScaleQ(key, symlog().constant(constant2), channels, options);
+function maybeRound(scale3, channels, options, key) {
+  let { round: round2 } = options;
+  if (round2 !== void 0)
+    scale3.round(round2 = !!round2);
+  scale3 = createScaleO(key, scale3, channels, options);
+  scale3.round = round2;
+  return scale3;
 }
-function createScaleQuantile(key, channels, {
-  range: range3,
-  quantiles = range3 === void 0 ? 5 : (range3 = [...range3]).length,
-  // deprecated; use n instead
-  n = quantiles,
-  scheme: scheme28 = "rdylbu",
-  domain = inferQuantileDomain(channels),
-  unknown,
-  interpolate,
-  reverse: reverse3
-}) {
-  if (range3 === void 0) {
-    range3 = interpolate !== void 0 ? quantize_default(interpolate, n) : registry.get(key) === color2 ? ordinalRange(scheme28, n) : void 0;
+function inferDomain2(channels, interval2, key) {
+  const values2 = new InternSet();
+  for (const { value, domain } of channels) {
+    if (domain !== void 0)
+      return domain();
+    if (value === void 0)
+      continue;
+    for (const v2 of value)
+      values2.add(v2);
   }
-  if (domain.length > 0) {
-    domain = quantile3(domain, range3 === void 0 ? { length: n } : range3).quantiles();
+  if (interval2 !== void 0) {
+    const [min5, max4] = extent(values2).map(interval2.floor, interval2);
+    return interval2.range(min5, interval2.offset(max4));
   }
-  return createScaleThreshold(key, channels, { domain, range: range3, reverse: reverse3, unknown });
+  if (values2.size > 1e4 && registry.get(key) === position) {
+    throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);
+  }
+  return sort(values2, ascendingDefined2);
 }
-function createScaleQuantize(key, channels, {
-  range: range3,
-  n = range3 === void 0 ? 5 : (range3 = [...range3]).length,
-  scheme: scheme28 = "rdylbu",
-  domain = inferAutoDomain(key, channels),
-  unknown,
-  interpolate,
-  reverse: reverse3
-}) {
-  const [min5, max4] = extent(domain);
-  let thresholds;
-  if (range3 === void 0) {
-    thresholds = ticks(min5, max4, n);
-    if (thresholds[0] <= min5)
-      thresholds.splice(0, 1);
-    if (thresholds[thresholds.length - 1] >= max4)
-      thresholds.pop();
-    n = thresholds.length + 1;
-    range3 = interpolate !== void 0 ? quantize_default(interpolate, n) : registry.get(key) === color2 ? ordinalRange(scheme28, n) : void 0;
-  } else {
-    thresholds = quantize_default(number_default(min5, max4), n + 1).slice(1, -1);
-    if (min5 instanceof Date)
-      thresholds = thresholds.map((x3) => new Date(x3));
+function inferHint(channels, key) {
+  let value;
+  for (const { hint } of channels) {
+    const candidate = hint?.[key];
+    if (candidate === void 0)
+      continue;
+    if (value === void 0)
+      value = candidate;
+    else if (value !== candidate)
+      return;
   }
-  if (orderof(arrayify2(domain)) < 0)
-    thresholds.reverse();
-  return createScaleThreshold(key, channels, { domain: thresholds, range: range3, reverse: reverse3, unknown });
+  return value;
 }
-function createScaleThreshold(key, channels, {
-  domain = [0],
-  // explicit thresholds in ascending order
-  unknown,
-  scheme: scheme28 = "rdylbu",
-  interpolate,
-  range: range3 = interpolate !== void 0 ? quantize_default(interpolate, domain.length + 1) : registry.get(key) === color2 ? ordinalRange(scheme28, domain.length + 1) : void 0,
-  reverse: reverse3
-}) {
-  domain = arrayify2(domain);
-  const sign3 = orderof(domain);
-  if (!isNaN(sign3) && !isOrdered(domain, sign3))
-    throw new Error(`the ${key} scale has a non-monotonic domain`);
-  if (reverse3)
-    range3 = reverse(range3);
+function inferSymbolHint(channels) {
   return {
-    type: "threshold",
-    scale: threshold(sign3 < 0 ? reverse(domain) : domain, range3 === void 0 ? [] : range3).unknown(unknown),
-    domain,
-    range: range3
+    fill: inferHint(channels, "fill"),
+    stroke: inferHint(channels, "stroke")
   };
 }
-function isOrdered(domain, sign3) {
-  for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {
-    const s2 = descending(d, d = domain[i]);
-    if (s2 !== 0 && s2 !== sign3)
-      return false;
-  }
-  return true;
-}
-function createScaleIdentity(key) {
-  return { type: "identity", scale: hasNumericRange(registry.get(key)) ? identity5() : (d) => d };
-}
-function inferDomain(channels, f = finite2) {
-  return channels.length ? [
-    min2(channels, ({ value }) => value === void 0 ? value : min2(value, f)),
-    max2(channels, ({ value }) => value === void 0 ? value : max2(value, f))
-  ] : [0, 1];
-}
-function inferAutoDomain(key, channels) {
-  const type2 = registry.get(key);
-  return (type2 === radius || type2 === opacity || type2 === length3 ? inferZeroDomain : inferDomain)(channels);
-}
-function inferZeroDomain(channels) {
-  return [0, channels.length ? max2(channels, ({ value }) => value === void 0 ? value : max2(value, finite2)) : 1];
-}
-function inferRadialRange(channels, domain) {
-  const hint = channels.find(({ radius: radius2 }) => radius2 !== void 0);
-  if (hint !== void 0)
-    return [0, hint.radius];
-  const h25 = quantile2(channels, 0.5, ({ value }) => value === void 0 ? NaN : quantile2(value, 0.25, positive));
-  const range3 = domain.map((d) => 3 * Math.sqrt(d / h25));
-  const k2 = 30 / max2(range3);
-  return k2 < 1 ? range3.map((r) => r * k2) : range3;
-}
-function inferLengthRange(channels, domain) {
-  const h50 = median2(channels, ({ value }) => value === void 0 ? NaN : median2(value, Math.abs));
-  const range3 = domain.map((d) => 12 * d / h50);
-  const k2 = 60 / max2(range3);
-  return k2 < 1 ? range3.map((r) => r * k2) : range3;
+function inferSymbolRange(hint) {
+  return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;
 }
-function inferLogDomain(channels) {
-  for (const { value } of channels) {
-    if (value !== void 0) {
-      for (let v2 of value) {
-        if (v2 > 0)
-          return inferDomain(channels, positive);
-        if (v2 < 0)
-          return inferDomain(channels, negative);
+
+// ../../node_modules/@observablehq/plot/src/scales.js
+function createScales(channelsByScale, {
+  label: globalLabel,
+  inset: globalInset = 0,
+  insetTop: globalInsetTop = globalInset,
+  insetRight: globalInsetRight = globalInset,
+  insetBottom: globalInsetBottom = globalInset,
+  insetLeft: globalInsetLeft = globalInset,
+  round: round2,
+  nice: nice3,
+  clamp,
+  zero: zero3,
+  align,
+  padding,
+  projection: projection3,
+  facet: { label: facetLabel = globalLabel } = {},
+  ...options
+} = {}) {
+  const scales2 = {};
+  for (const [key, channels] of channelsByScale) {
+    const scaleOptions = options[key];
+    const scale3 = createScale(key, channels, {
+      round: registry.get(key) === position ? round2 : void 0,
+      // only for position
+      nice: nice3,
+      clamp,
+      zero: zero3,
+      align,
+      padding,
+      projection: projection3,
+      ...scaleOptions
+    });
+    if (scale3) {
+      let {
+        label = key === "fx" || key === "fy" ? facetLabel : globalLabel,
+        percent,
+        transform: transform3,
+        inset,
+        insetTop = inset !== void 0 ? inset : key === "y" ? globalInsetTop : 0,
+        // not fy
+        insetRight = inset !== void 0 ? inset : key === "x" ? globalInsetRight : 0,
+        // not fx
+        insetBottom = inset !== void 0 ? inset : key === "y" ? globalInsetBottom : 0,
+        // not fy
+        insetLeft = inset !== void 0 ? inset : key === "x" ? globalInsetLeft : 0
+        // not fx
+      } = scaleOptions || {};
+      if (transform3 == null)
+        transform3 = void 0;
+      else if (typeof transform3 !== "function")
+        throw new Error("invalid scale transform; not a function");
+      scale3.percent = !!percent;
+      scale3.label = label === void 0 ? inferScaleLabel(channels, scale3) : label;
+      scale3.transform = transform3;
+      if (key === "x" || key === "fx") {
+        scale3.insetLeft = +insetLeft;
+        scale3.insetRight = +insetRight;
+      } else if (key === "y" || key === "fy") {
+        scale3.insetTop = +insetTop;
+        scale3.insetBottom = +insetBottom;
       }
+      scales2[key] = scale3;
     }
   }
-  return [1, 10];
+  return scales2;
 }
-function inferQuantileDomain(channels) {
-  const domain = [];
-  for (const { value } of channels) {
-    if (value === void 0)
-      continue;
-    for (const v2 of value)
-      domain.push(v2);
+function createScaleFunctions(descriptors) {
+  const scales2 = {};
+  const scaleFunctions = { scales: scales2 };
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    const { scale: scale3, type: type2, interval: interval2, label } = descriptor;
+    scales2[key] = exposeScale(descriptor);
+    scaleFunctions[key] = scale3;
+    scale3.type = type2;
+    if (interval2 != null)
+      scale3.interval = interval2;
+    if (label != null)
+      scale3.label = label;
   }
-  return domain;
+  return scaleFunctions;
 }
-function interpolatePiecewise(interpolate) {
-  return (i, j) => (t) => interpolate(i + t * (j - i));
+function autoScaleRange(scales2, dimensions) {
+  const { x: x3, y: y3, fx, fy } = scales2;
+  const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;
+  if (fx)
+    autoScaleRangeX(fx, superdimensions);
+  if (fy)
+    autoScaleRangeY(fy, superdimensions);
+  const subdimensions = fx || fy ? innerDimensions(scales2, dimensions) : dimensions;
+  if (x3)
+    autoScaleRangeX(x3, subdimensions);
+  if (y3)
+    autoScaleRangeY(y3, subdimensions);
 }
-
-// ../../node_modules/@observablehq/plot/src/scales/diverging.js
-function createScaleD(key, scale3, transform3, channels, {
-  type: type2,
-  nice: nice3,
-  clamp,
-  domain = inferDomain(channels),
-  unknown,
-  pivot = 0,
-  scheme: scheme28,
-  range: range3,
-  symmetric = true,
-  interpolate = registry.get(key) === color2 ? scheme28 == null && range3 !== void 0 ? rgb_default : quantitativeScheme(scheme28 !== void 0 ? scheme28 : "rdbu") : number_default,
-  reverse: reverse3
-}) {
-  pivot = +pivot;
-  domain = arrayify2(domain);
-  let [min5, max4] = domain;
-  if (domain.length > 2)
-    warn(`Warning: the diverging ${key} scale domain contains extra elements.`);
-  if (descending(min5, max4) < 0)
-    [min5, max4] = [max4, min5], reverse3 = !reverse3;
-  min5 = Math.min(min5, pivot);
-  max4 = Math.max(max4, pivot);
-  if (typeof interpolate !== "function") {
-    interpolate = maybeInterpolator(interpolate);
-  }
-  if (range3 !== void 0) {
-    interpolate = interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range3) : piecewise(interpolate, range3);
-  }
-  if (reverse3)
-    interpolate = flip(interpolate);
-  if (symmetric) {
-    const mid2 = transform3.apply(pivot);
-    const mindelta = mid2 - transform3.apply(min5);
-    const maxdelta = transform3.apply(max4) - mid2;
-    if (mindelta < maxdelta)
-      min5 = transform3.invert(mid2 - maxdelta);
-    else if (mindelta > maxdelta)
-      max4 = transform3.invert(mid2 + mindelta);
+function inferScaleLabel(channels = [], scale3) {
+  let label;
+  for (const { label: l } of channels) {
+    if (l === void 0)
+      continue;
+    if (label === void 0)
+      label = l;
+    else if (label !== l)
+      return;
   }
-  scale3.domain([min5, pivot, max4]).unknown(unknown).interpolator(interpolate);
-  if (clamp)
-    scale3.clamp(clamp);
-  if (nice3)
-    scale3.nice(nice3);
-  return { type: type2, domain: [min5, max4], pivot, interpolate, scale: scale3 };
-}
-function createScaleDiverging(key, channels, options) {
-  return createScaleD(key, diverging(), transformIdentity, channels, options);
-}
-function createScaleDivergingSqrt(key, channels, options) {
-  return createScaleDivergingPow(key, channels, { ...options, exponent: 0.5 });
-}
-function createScaleDivergingPow(key, channels, { exponent = 1, ...options }) {
-  return createScaleD(key, divergingPow().exponent(exponent = +exponent), transformPow2(exponent), channels, {
-    ...options,
-    type: "diverging-pow"
-  });
-}
-function createScaleDivergingLog(key, channels, { base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options }) {
-  return createScaleD(key, divergingLog().base(base = +base), transformLog2, channels, {
-    domain,
-    pivot,
-    ...options
-  });
+  if (label === void 0)
+    return;
+  if (!isOrdinalScale(scale3) && scale3.percent)
+    label = `${label} (%)`;
+  return { inferred: true, toString: () => label };
 }
-function createScaleDivergingSymlog(key, channels, { constant: constant2 = 1, ...options }) {
-  return createScaleD(
-    key,
-    divergingSymlog().constant(constant2 = +constant2),
-    transformSymlog2(constant2),
-    channels,
-    options
-  );
+function inferScaleOrder(scale3) {
+  return Math.sign(orderof(scale3.domain())) * Math.sign(orderof(scale3.range()));
 }
-var transformIdentity = {
-  apply(x3) {
-    return x3;
-  },
-  invert(x3) {
-    return x3;
-  }
-};
-var transformLog2 = {
-  apply: Math.log,
-  invert: Math.exp
-};
-var transformSqrt2 = {
-  apply(x3) {
-    return Math.sign(x3) * Math.sqrt(Math.abs(x3));
-  },
-  invert(x3) {
-    return Math.sign(x3) * (x3 * x3);
-  }
-};
-function transformPow2(exponent) {
-  return exponent === 0.5 ? transformSqrt2 : {
-    apply(x3) {
-      return Math.sign(x3) * Math.pow(Math.abs(x3), exponent);
-    },
-    invert(x3) {
-      return Math.sign(x3) * Math.pow(Math.abs(x3), 1 / exponent);
+function outerDimensions(dimensions) {
+  const {
+    marginTop,
+    marginRight,
+    marginBottom,
+    marginLeft,
+    width,
+    height,
+    facet: {
+      marginTop: facetMarginTop,
+      marginRight: facetMarginRight,
+      marginBottom: facetMarginBottom,
+      marginLeft: facetMarginLeft
     }
+  } = dimensions;
+  return {
+    marginTop: Math.max(marginTop, facetMarginTop),
+    marginRight: Math.max(marginRight, facetMarginRight),
+    marginBottom: Math.max(marginBottom, facetMarginBottom),
+    marginLeft: Math.max(marginLeft, facetMarginLeft),
+    width,
+    height
   };
 }
-function transformSymlog2(constant2) {
+function innerDimensions({ fx, fy }, dimensions) {
+  const { marginTop, marginRight, marginBottom, marginLeft, width, height } = outerDimensions(dimensions);
   return {
-    apply(x3) {
-      return Math.sign(x3) * Math.log1p(Math.abs(x3 / constant2));
-    },
-    invert(x3) {
-      return Math.sign(x3) * Math.expm1(Math.abs(x3)) * constant2;
-    }
+    marginTop,
+    marginRight,
+    marginBottom,
+    marginLeft,
+    width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,
+    height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height,
+    facet: { width, height }
   };
 }
-
-// ../../node_modules/@observablehq/plot/src/scales/temporal.js
-function createScaleT(key, scale3, channels, options) {
-  return createScaleQ(key, scale3, channels, options);
+function autoScaleRangeX(scale3, dimensions) {
+  if (scale3.range === void 0) {
+    const { insetLeft, insetRight } = scale3;
+    const { width, marginLeft = 0, marginRight = 0 } = dimensions;
+    const left2 = marginLeft + insetLeft;
+    const right2 = width - marginRight - insetRight;
+    scale3.range = [left2, Math.max(left2, right2)];
+    if (!isOrdinalScale(scale3))
+      scale3.range = piecewiseRange(scale3);
+    scale3.scale.range(scale3.range);
+  }
+  autoScaleRound(scale3);
+}
+function autoScaleRangeY(scale3, dimensions) {
+  if (scale3.range === void 0) {
+    const { insetTop, insetBottom } = scale3;
+    const { height, marginTop = 0, marginBottom = 0 } = dimensions;
+    const top2 = marginTop + insetTop;
+    const bottom2 = height - marginBottom - insetBottom;
+    scale3.range = [Math.max(top2, bottom2), top2];
+    if (!isOrdinalScale(scale3))
+      scale3.range = piecewiseRange(scale3);
+    else
+      scale3.range.reverse();
+    scale3.scale.range(scale3.range);
+  }
+  autoScaleRound(scale3);
+}
+function autoScaleRound(scale3) {
+  if (scale3.round === void 0 && isBandScale(scale3) && roundError(scale3) <= 30) {
+    scale3.scale.round(true);
+  }
+}
+function roundError({ scale: scale3 }) {
+  const n = scale3.domain().length;
+  const [start2, stop] = scale3.range();
+  const paddingInner = scale3.paddingInner ? scale3.paddingInner() : 1;
+  const paddingOuter = scale3.paddingOuter ? scale3.paddingOuter() : scale3.padding();
+  const m = n - paddingInner;
+  const step = Math.abs(stop - start2) / Math.max(1, m + paddingOuter * 2);
+  return (step - Math.floor(step)) * m;
 }
-function createScaleTime(key, channels, options) {
-  return createScaleT(key, time(), channels, options);
+function piecewiseRange(scale3) {
+  const length4 = scale3.scale.domain().length + isThresholdScale(scale3);
+  if (!(length4 > 2))
+    return scale3.range;
+  const [start2, end] = scale3.range;
+  return Array.from({ length: length4 }, (_, i) => start2 + i / (length4 - 1) * (end - start2));
 }
-function createScaleUtc(key, channels, options) {
-  return createScaleT(key, utcTime(), channels, options);
+function normalizeScale(key, scale3, hint) {
+  return createScale(key, hint === void 0 ? void 0 : [{ hint }], { ...scale3 });
 }
-
-// ../../node_modules/@observablehq/plot/src/scales/ordinal.js
-var ordinalImplicit = Symbol("ordinal");
-function createScaleO(key, scale3, channels, { type: type2, interval: interval2, domain, range: range3, reverse: reverse3, hint }) {
-  interval2 = maybeRangeInterval(interval2, type2);
-  if (domain === void 0)
-    domain = inferDomain2(channels, interval2, key);
-  if (type2 === "categorical" || type2 === ordinalImplicit)
-    type2 = "ordinal";
-  if (reverse3)
-    domain = reverse(domain);
-  domain = scale3.domain(domain).domain();
-  if (range3 !== void 0) {
-    if (typeof range3 === "function")
-      range3 = range3(domain);
-    scale3.range(range3);
+function createScale(key, channels = [], options = {}) {
+  const type2 = inferScaleType(key, channels, options);
+  if (options.type === void 0 && options.domain === void 0 && options.range === void 0 && options.interval == null && key !== "fx" && key !== "fy" && isOrdinalScale({ type: type2 })) {
+    const values2 = channels.map(({ value }) => value).filter((value) => value !== void 0);
+    if (values2.some(isTemporal))
+      warn(
+        `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType(
+          type2
+        )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
+          type2
+        )}".`
+      );
+    else if (values2.some(isTemporalString))
+      warn(
+        `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType(
+          type2
+        )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
+          type2
+        )}".`
+      );
+    else if (values2.some(isNumericString))
+      warn(
+        `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType(
+          type2
+        )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
+          type2
+        )}".`
+      );
   }
-  return { type: type2, domain, range: range3, scale: scale3, hint, interval: interval2 };
-}
-function createScaleOrdinal(key, channels, { type: type2, interval: interval2, domain, range: range3, scheme: scheme28, unknown, ...options }) {
-  interval2 = maybeRangeInterval(interval2, type2);
-  if (domain === void 0)
-    domain = inferDomain2(channels, interval2, key);
-  let hint;
-  if (registry.get(key) === symbol) {
-    hint = inferSymbolHint(channels);
-    range3 = range3 === void 0 ? inferSymbolRange(hint) : map2(range3, maybeSymbol);
-  } else if (registry.get(key) === color2) {
-    if (range3 === void 0 && (type2 === "ordinal" || type2 === ordinalImplicit)) {
-      range3 = maybeBooleanRange(domain, scheme28);
-      if (range3 !== void 0)
-        scheme28 = void 0;
-    }
-    if (scheme28 === void 0 && range3 === void 0) {
-      scheme28 = type2 === "ordinal" ? "turbo" : "observable10";
-    }
-    if (scheme28 !== void 0) {
-      if (range3 !== void 0) {
-        const interpolate = quantitativeScheme(scheme28);
-        const t03 = range3[0], d = range3[1] - range3[0];
-        range3 = ({ length: n }) => quantize_default((t) => interpolate(t03 + d * t), n);
-      } else {
-        range3 = ordinalScheme(scheme28);
+  options.type = type2;
+  switch (type2) {
+    case "diverging":
+    case "diverging-sqrt":
+    case "diverging-pow":
+    case "diverging-log":
+    case "diverging-symlog":
+    case "cyclical":
+    case "sequential":
+    case "linear":
+    case "sqrt":
+    case "threshold":
+    case "quantile":
+    case "pow":
+    case "log":
+    case "symlog":
+      options = coerceType(channels, options, coerceNumbers);
+      break;
+    case "identity":
+      switch (registry.get(key)) {
+        case position:
+          options = coerceType(channels, options, coerceNumbers);
+          break;
+        case symbol:
+          options = coerceType(channels, options, coerceSymbols);
+          break;
       }
-    }
+      break;
+    case "utc":
+    case "time":
+      options = coerceType(channels, options, coerceDates);
+      break;
   }
-  if (unknown === implicit) {
-    throw new Error(`implicit unknown on ${key} scale is not supported`);
+  switch (type2) {
+    case "diverging":
+      return createScaleDiverging(key, channels, options);
+    case "diverging-sqrt":
+      return createScaleDivergingSqrt(key, channels, options);
+    case "diverging-pow":
+      return createScaleDivergingPow(key, channels, options);
+    case "diverging-log":
+      return createScaleDivergingLog(key, channels, options);
+    case "diverging-symlog":
+      return createScaleDivergingSymlog(key, channels, options);
+    case "categorical":
+    case "ordinal":
+    case ordinalImplicit:
+      return createScaleOrdinal(key, channels, options);
+    case "cyclical":
+    case "sequential":
+    case "linear":
+      return createScaleLinear(key, channels, options);
+    case "sqrt":
+      return createScaleSqrt(key, channels, options);
+    case "threshold":
+      return createScaleThreshold(key, channels, options);
+    case "quantile":
+      return createScaleQuantile(key, channels, options);
+    case "quantize":
+      return createScaleQuantize(key, channels, options);
+    case "pow":
+      return createScalePow(key, channels, options);
+    case "log":
+      return createScaleLog(key, channels, options);
+    case "symlog":
+      return createScaleSymlog(key, channels, options);
+    case "utc":
+      return createScaleUtc(key, channels, options);
+    case "time":
+      return createScaleTime(key, channels, options);
+    case "point":
+      return createScalePoint(key, channels, options);
+    case "band":
+      return createScaleBand(key, channels, options);
+    case "identity":
+      return createScaleIdentity(key);
+    case void 0:
+      return;
+    default:
+      throw new Error(`unknown scale type: ${type2}`);
   }
-  return createScaleO(key, ordinal().unknown(unknown), channels, { ...options, type: type2, domain, range: range3, hint });
-}
-function createScalePoint(key, channels, { align = 0.5, padding = 0.5, ...options }) {
-  return maybeRound(point().align(align).padding(padding), channels, options, key);
 }
-function createScaleBand(key, channels, {
-  align = 0.5,
-  padding = 0.1,
-  paddingInner = padding,
-  paddingOuter = key === "fx" || key === "fy" ? 0 : padding,
-  ...options
-}) {
-  return maybeRound(
-    band().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),
-    channels,
-    options,
-    key
-  );
+function formatScaleType(type2) {
+  return typeof type2 === "symbol" ? type2.description : type2;
 }
-function maybeRound(scale3, channels, options, key) {
-  let { round: round2 } = options;
-  if (round2 !== void 0)
-    scale3.round(round2 = !!round2);
-  scale3 = createScaleO(key, scale3, channels, options);
-  scale3.round = round2;
-  return scale3;
+function maybeScaleType(type2) {
+  return typeof type2 === "string" ? `${type2}`.toLowerCase() : type2;
 }
-function inferDomain2(channels, interval2, key) {
-  const values2 = new InternSet();
-  for (const { value, domain } of channels) {
-    if (domain !== void 0)
-      return domain();
-    if (value === void 0)
+var typeProjection = { toString: () => "projection" };
+function inferScaleType(key, channels, { type: type2, domain, range: range3, scheme: scheme28, pivot, projection: projection3 }) {
+  type2 = maybeScaleType(type2);
+  if (key === "fx" || key === "fy")
+    return "band";
+  if ((key === "x" || key === "y") && projection3 != null)
+    type2 = typeProjection;
+  for (const channel of channels) {
+    const t = maybeScaleType(channel.type);
+    if (t === void 0)
       continue;
-    for (const v2 of value)
-      values2.add(v2);
+    else if (type2 === void 0)
+      type2 = t;
+    else if (type2 !== t)
+      throw new Error(`scale incompatible with channel: ${type2} !== ${t}`);
+  }
+  if (type2 === typeProjection)
+    return;
+  if (type2 !== void 0)
+    return type2;
+  if (domain === void 0 && !channels.some(({ value }) => value !== void 0))
+    return;
+  const kind = registry.get(key);
+  if (kind === radius)
+    return "sqrt";
+  if (kind === opacity || kind === length3)
+    return "linear";
+  if (kind === symbol)
+    return "ordinal";
+  if ((domain || range3 || []).length > 2)
+    return asOrdinalType(kind);
+  if (domain !== void 0) {
+    if (isOrdinal(domain))
+      return asOrdinalType(kind);
+    if (isTemporal(domain))
+      return "utc";
+  } else {
+    const values2 = channels.map(({ value }) => value).filter((value) => value !== void 0);
+    if (values2.some(isOrdinal))
+      return asOrdinalType(kind);
+    if (values2.some(isTemporal))
+      return "utc";
+  }
+  if (kind === color2) {
+    if (pivot != null || isDivergingScheme(scheme28))
+      return "diverging";
+    if (isCategoricalScheme(scheme28))
+      return "categorical";
+  }
+  return "linear";
+}
+function asOrdinalType(kind) {
+  switch (kind) {
+    case position:
+      return "point";
+    case color2:
+      return ordinalImplicit;
+    default:
+      return "ordinal";
   }
-  if (interval2 !== void 0) {
-    const [min5, max4] = extent(values2).map(interval2.floor, interval2);
-    return interval2.range(min5, interval2.offset(max4));
+}
+function isOrdinalScale({ type: type2 }) {
+  return type2 === "ordinal" || type2 === "point" || type2 === "band" || type2 === ordinalImplicit;
+}
+function isThresholdScale({ type: type2 }) {
+  return type2 === "threshold";
+}
+function isBandScale({ type: type2 }) {
+  return type2 === "point" || type2 === "band";
+}
+function isCollapsed(scale3) {
+  if (scale3 === void 0)
+    return true;
+  const domain = scale3.domain();
+  const value = scale3(domain[0]);
+  for (let i = 1, n = domain.length; i < n; ++i) {
+    if (scale3(domain[i]) - value) {
+      return false;
+    }
   }
-  if (values2.size > 1e4 && registry.get(key) === position) {
-    throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);
+  return true;
+}
+function coerceType(channels, { domain, ...options }, coerceValues) {
+  for (const c4 of channels) {
+    if (c4.value !== void 0) {
+      if (domain === void 0)
+        domain = c4.value?.domain;
+      c4.value = coerceValues(c4.value);
+    }
   }
-  return sort(values2, ascendingDefined2);
+  return {
+    domain: domain === void 0 ? domain : coerceValues(domain),
+    ...options
+  };
 }
-function inferHint(channels, key) {
-  let value;
-  for (const { hint } of channels) {
-    const candidate = hint?.[key];
-    if (candidate === void 0)
+function coerceSymbols(values2) {
+  return map2(values2, maybeSymbol);
+}
+function scale2(options = {}) {
+  let scale3;
+  for (const key in options) {
+    if (!registry.has(key))
       continue;
-    if (value === void 0)
-      value = candidate;
-    else if (value !== candidate)
-      return;
+    if (!isScaleOptions(options[key]))
+      continue;
+    if (scale3 !== void 0)
+      throw new Error("ambiguous scale definition; multiple scales found");
+    scale3 = exposeScale(normalizeScale(key, options[key]));
   }
-  return value;
+  if (scale3 === void 0)
+    throw new Error("invalid scale definition; no scale found");
+  return scale3;
 }
-function inferSymbolHint(channels) {
-  return {
-    fill: inferHint(channels, "fill"),
-    stroke: inferHint(channels, "stroke")
+function exposeScales(scales2) {
+  return (key) => {
+    if (!registry.has(key = `${key}`))
+      throw new Error(`unknown scale: ${key}`);
+    return scales2[key];
   };
 }
-function inferSymbolRange(hint) {
-  return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;
+function exposeScale({ scale: scale3, type: type2, domain, range: range3, interpolate, interval: interval2, transform: transform3, percent, pivot }) {
+  if (type2 === "identity")
+    return { type: "identity", apply: (d) => d, invert: (d) => d };
+  const unknown = scale3.unknown ? scale3.unknown() : void 0;
+  return {
+    type: type2,
+    domain: slice3(domain),
+    // defensive copy
+    ...range3 !== void 0 && { range: slice3(range3) },
+    // defensive copy
+    ...transform3 !== void 0 && { transform: transform3 },
+    ...percent && { percent },
+    // only exposed if truthy
+    ...unknown !== void 0 && { unknown },
+    ...interval2 !== void 0 && { interval: interval2 },
+    // quantitative
+    ...interpolate !== void 0 && { interpolate },
+    ...scale3.clamp && { clamp: scale3.clamp() },
+    // diverging (always asymmetric; we never want to apply the symmetric transform twice)
+    ...pivot !== void 0 && { pivot, symmetric: false },
+    // log, diverging-log
+    ...scale3.base && { base: scale3.base() },
+    // pow, diverging-pow
+    ...scale3.exponent && { exponent: scale3.exponent() },
+    // symlog, diverging-symlog
+    ...scale3.constant && { constant: scale3.constant() },
+    // band, point
+    ...scale3.align && { align: scale3.align(), round: scale3.round() },
+    ...scale3.padding && (scale3.paddingInner ? { paddingInner: scale3.paddingInner(), paddingOuter: scale3.paddingOuter() } : { padding: scale3.padding() }),
+    ...scale3.bandwidth && { bandwidth: scale3.bandwidth(), step: scale3.step() },
+    // utilities
+    apply: (t) => scale3(t),
+    ...scale3.invert && { invert: (t) => scale3.invert(t) }
+  };
 }
 
-// ../../node_modules/@observablehq/plot/src/scales.js
-function createScales(channelsByScale, {
-  label: globalLabel,
-  inset: globalInset = 0,
-  insetTop: globalInsetTop = globalInset,
-  insetRight: globalInsetRight = globalInset,
-  insetBottom: globalInsetBottom = globalInset,
-  insetLeft: globalInsetLeft = globalInset,
-  round: round2,
-  nice: nice3,
-  clamp,
-  zero: zero3,
-  align,
-  padding,
-  projection: projection3,
-  facet: { label: facetLabel = globalLabel } = {},
-  ...options
-} = {}) {
-  const scales2 = {};
-  for (const [key, channels] of channelsByScale) {
-    const scaleOptions = options[key];
-    const scale3 = createScale(key, channels, {
-      round: registry.get(key) === position ? round2 : void 0,
-      // only for position
-      nice: nice3,
-      clamp,
-      zero: zero3,
-      align,
-      padding,
-      projection: projection3,
-      ...scaleOptions
-    });
-    if (scale3) {
-      let {
-        label = key === "fx" || key === "fy" ? facetLabel : globalLabel,
-        percent,
-        transform: transform3,
-        inset,
-        insetTop = inset !== void 0 ? inset : key === "y" ? globalInsetTop : 0,
-        // not fy
-        insetRight = inset !== void 0 ? inset : key === "x" ? globalInsetRight : 0,
-        // not fx
-        insetBottom = inset !== void 0 ? inset : key === "y" ? globalInsetBottom : 0,
-        // not fy
-        insetLeft = inset !== void 0 ? inset : key === "x" ? globalInsetLeft : 0
-        // not fx
-      } = scaleOptions || {};
-      if (transform3 == null)
-        transform3 = void 0;
-      else if (typeof transform3 !== "function")
-        throw new Error("invalid scale transform; not a function");
-      scale3.percent = !!percent;
-      scale3.label = label === void 0 ? inferScaleLabel(channels, scale3) : label;
-      scale3.transform = transform3;
-      if (key === "x" || key === "fx") {
-        scale3.insetLeft = +insetLeft;
-        scale3.insetRight = +insetRight;
-      } else if (key === "y" || key === "fy") {
-        scale3.insetTop = +insetTop;
-        scale3.insetBottom = +insetBottom;
-      }
-      scales2[key] = scale3;
+// ../../node_modules/@observablehq/plot/src/memoize.js
+function memoize1(compute) {
+  let cacheValue, cacheKeys;
+  return (...keys) => {
+    if (cacheKeys?.length !== keys.length || cacheKeys.some((k2, i) => k2 !== keys[i])) {
+      cacheKeys = keys;
+      cacheValue = compute(...keys);
     }
+    return cacheValue;
+  };
+}
+
+// ../../node_modules/@observablehq/plot/src/format.js
+var numberFormat = memoize1((locale3) => {
+  return new Intl.NumberFormat(locale3);
+});
+var monthFormat = memoize1((locale3, month) => {
+  return new Intl.DateTimeFormat(locale3, { timeZone: "UTC", ...month && { month } });
+});
+var weekdayFormat = memoize1((locale3, weekday) => {
+  return new Intl.DateTimeFormat(locale3, { timeZone: "UTC", ...weekday && { weekday } });
+});
+function formatNumber(locale3 = "en-US") {
+  const format3 = numberFormat(locale3);
+  return (i) => i != null && !isNaN(i) ? format3.format(i) : void 0;
+}
+function formatMonth(locale3 = "en-US", format3 = "short") {
+  const fmt = monthFormat(locale3, format3);
+  return (i) => i != null && !isNaN(i = +new Date(Date.UTC(2e3, +i))) ? fmt.format(i) : void 0;
+}
+function formatWeekday(locale3 = "en-US", format3 = "short") {
+  const fmt = weekdayFormat(locale3, format3);
+  return (i) => i != null && !isNaN(i = +new Date(Date.UTC(2001, 0, +i))) ? fmt.format(i) : void 0;
+}
+function formatIsoDate(date2) {
+  return format2(date2, "Invalid Date");
+}
+function formatAuto(locale3 = "en-US") {
+  const number7 = formatNumber(locale3);
+  return (v2) => (v2 instanceof Date ? formatIsoDate : typeof v2 === "number" ? number7 : string)(v2);
+}
+var formatDefault = formatAuto();
+
+// ../../node_modules/@observablehq/plot/src/style.js
+var offset = (typeof window !== "undefined" ? window.devicePixelRatio > 1 : typeof it === "undefined") ? 0 : 0.5;
+var nextClipId = 0;
+function getClipId() {
+  return `plot-clip-${++nextClipId}`;
+}
+function styles(mark, {
+  title,
+  href,
+  ariaLabel: variaLabel,
+  ariaDescription,
+  ariaHidden,
+  target,
+  fill,
+  fillOpacity,
+  stroke,
+  strokeWidth,
+  strokeOpacity,
+  strokeLinejoin,
+  strokeLinecap,
+  strokeMiterlimit,
+  strokeDasharray,
+  strokeDashoffset,
+  opacity: opacity2,
+  mixBlendMode,
+  imageFilter,
+  paintOrder,
+  pointerEvents,
+  shapeRendering,
+  channels
+}, {
+  ariaLabel: cariaLabel,
+  fill: defaultFill = "currentColor",
+  fillOpacity: defaultFillOpacity,
+  stroke: defaultStroke = "none",
+  strokeOpacity: defaultStrokeOpacity,
+  strokeWidth: defaultStrokeWidth,
+  strokeLinecap: defaultStrokeLinecap,
+  strokeLinejoin: defaultStrokeLinejoin,
+  strokeMiterlimit: defaultStrokeMiterlimit,
+  paintOrder: defaultPaintOrder
+}) {
+  if (defaultFill === null) {
+    fill = null;
+    fillOpacity = null;
   }
-  return scales2;
-}
-function createScaleFunctions(descriptors) {
-  const scales2 = {};
-  const scaleFunctions = { scales: scales2 };
-  for (const [key, descriptor] of Object.entries(descriptors)) {
-    const { scale: scale3, type: type2, interval: interval2, label } = descriptor;
-    scales2[key] = exposeScale(descriptor);
-    scaleFunctions[key] = scale3;
-    scale3.type = type2;
-    if (interval2 != null)
-      scale3.interval = interval2;
-    if (label != null)
-      scale3.label = label;
+  if (defaultStroke === null) {
+    stroke = null;
+    strokeOpacity = null;
   }
-  return scaleFunctions;
-}
-function autoScaleRange(scales2, dimensions) {
-  const { x: x3, y: y3, fx, fy } = scales2;
-  const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;
-  if (fx)
-    autoScaleRangeX(fx, superdimensions);
-  if (fy)
-    autoScaleRangeY(fy, superdimensions);
-  const subdimensions = fx || fy ? innerDimensions(scales2, dimensions) : dimensions;
-  if (x3)
-    autoScaleRangeX(x3, subdimensions);
-  if (y3)
-    autoScaleRangeY(y3, subdimensions);
-}
-function inferScaleLabel(channels = [], scale3) {
-  let label;
-  for (const { label: l } of channels) {
-    if (l === void 0)
-      continue;
-    if (label === void 0)
-      label = l;
-    else if (label !== l)
-      return;
+  if (isNoneish(defaultFill)) {
+    if (!isNoneish(defaultStroke) && (!isNoneish(fill) || channels?.fill))
+      defaultStroke = "none";
+  } else {
+    if (isNoneish(defaultStroke) && (!isNoneish(stroke) || channels?.stroke))
+      defaultFill = "none";
   }
-  if (label === void 0)
-    return;
-  if (!isOrdinalScale(scale3) && scale3.percent)
-    label = `${label} (%)`;
-  return { inferred: true, toString: () => label };
-}
-function inferScaleOrder(scale3) {
-  return Math.sign(orderof(scale3.domain())) * Math.sign(orderof(scale3.range()));
-}
-function outerDimensions(dimensions) {
-  const {
-    marginTop,
-    marginRight,
-    marginBottom,
-    marginLeft,
-    width,
-    height,
-    facet: {
-      marginTop: facetMarginTop,
-      marginRight: facetMarginRight,
-      marginBottom: facetMarginBottom,
-      marginLeft: facetMarginLeft
-    }
-  } = dimensions;
+  const [vfill, cfill] = maybeColorChannel(fill, defaultFill);
+  const [vfillOpacity, cfillOpacity] = maybeNumberChannel(fillOpacity, defaultFillOpacity);
+  const [vstroke, cstroke] = maybeColorChannel(stroke, defaultStroke);
+  const [vstrokeOpacity, cstrokeOpacity] = maybeNumberChannel(strokeOpacity, defaultStrokeOpacity);
+  const [vopacity, copacity] = maybeNumberChannel(opacity2);
+  if (!isNone(cstroke)) {
+    if (strokeWidth === void 0)
+      strokeWidth = defaultStrokeWidth;
+    if (strokeLinecap === void 0)
+      strokeLinecap = defaultStrokeLinecap;
+    if (strokeLinejoin === void 0)
+      strokeLinejoin = defaultStrokeLinejoin;
+    if (strokeMiterlimit === void 0 && !isRound(strokeLinejoin))
+      strokeMiterlimit = defaultStrokeMiterlimit;
+    if (!isNone(cfill) && paintOrder === void 0)
+      paintOrder = defaultPaintOrder;
+  }
+  const [vstrokeWidth, cstrokeWidth] = maybeNumberChannel(strokeWidth);
+  if (defaultFill !== null) {
+    mark.fill = impliedString(cfill, "currentColor");
+    mark.fillOpacity = impliedNumber(cfillOpacity, 1);
+  }
+  if (defaultStroke !== null) {
+    mark.stroke = impliedString(cstroke, "none");
+    mark.strokeWidth = impliedNumber(cstrokeWidth, 1);
+    mark.strokeOpacity = impliedNumber(cstrokeOpacity, 1);
+    mark.strokeLinejoin = impliedString(strokeLinejoin, "miter");
+    mark.strokeLinecap = impliedString(strokeLinecap, "butt");
+    mark.strokeMiterlimit = impliedNumber(strokeMiterlimit, 4);
+    mark.strokeDasharray = impliedString(strokeDasharray, "none");
+    mark.strokeDashoffset = impliedString(strokeDashoffset, "0");
+  }
+  mark.target = string(target);
+  mark.ariaLabel = string(cariaLabel);
+  mark.ariaDescription = string(ariaDescription);
+  mark.ariaHidden = string(ariaHidden);
+  mark.opacity = impliedNumber(copacity, 1);
+  mark.mixBlendMode = impliedString(mixBlendMode, "normal");
+  mark.imageFilter = impliedString(imageFilter, "none");
+  mark.paintOrder = impliedString(paintOrder, "normal");
+  mark.pointerEvents = impliedString(pointerEvents, "auto");
+  mark.shapeRendering = impliedString(shapeRendering, "auto");
   return {
-    marginTop: Math.max(marginTop, facetMarginTop),
-    marginRight: Math.max(marginRight, facetMarginRight),
-    marginBottom: Math.max(marginBottom, facetMarginBottom),
-    marginLeft: Math.max(marginLeft, facetMarginLeft),
-    width,
-    height
+    title: { value: title, optional: true, filter: null },
+    href: { value: href, optional: true, filter: null },
+    ariaLabel: { value: variaLabel, optional: true, filter: null },
+    fill: { value: vfill, scale: "auto", optional: true },
+    fillOpacity: { value: vfillOpacity, scale: "auto", optional: true },
+    stroke: { value: vstroke, scale: "auto", optional: true },
+    strokeOpacity: { value: vstrokeOpacity, scale: "auto", optional: true },
+    strokeWidth: { value: vstrokeWidth, optional: true },
+    opacity: { value: vopacity, scale: "auto", optional: true }
   };
 }
-function innerDimensions({ fx, fy }, dimensions) {
-  const { marginTop, marginRight, marginBottom, marginLeft, width, height } = outerDimensions(dimensions);
-  return {
-    marginTop,
-    marginRight,
-    marginBottom,
-    marginLeft,
-    width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,
-    height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height,
-    facet: { width, height }
-  };
+function applyTitle(selection2, L) {
+  if (L)
+    selection2.filter((i) => nonempty(L[i])).append("title").call(applyText, L);
 }
-function autoScaleRangeX(scale3, dimensions) {
-  if (scale3.range === void 0) {
-    const { insetLeft, insetRight } = scale3;
-    const { width, marginLeft = 0, marginRight = 0 } = dimensions;
-    const left2 = marginLeft + insetLeft;
-    const right2 = width - marginRight - insetRight;
-    scale3.range = [left2, Math.max(left2, right2)];
-    if (!isOrdinalScale(scale3))
-      scale3.range = piecewiseRange(scale3);
-    scale3.scale.range(scale3.range);
-  }
-  autoScaleRound(scale3);
+function applyTitleGroup(selection2, L) {
+  if (L)
+    selection2.filter(([i]) => nonempty(L[i])).append("title").call(applyTextGroup, L);
 }
-function autoScaleRangeY(scale3, dimensions) {
-  if (scale3.range === void 0) {
-    const { insetTop, insetBottom } = scale3;
-    const { height, marginTop = 0, marginBottom = 0 } = dimensions;
-    const top2 = marginTop + insetTop;
-    const bottom2 = height - marginBottom - insetBottom;
-    scale3.range = [Math.max(top2, bottom2), top2];
-    if (!isOrdinalScale(scale3))
-      scale3.range = piecewiseRange(scale3);
-    else
-      scale3.range.reverse();
-    scale3.scale.range(scale3.range);
-  }
-  autoScaleRound(scale3);
+function applyText(selection2, T) {
+  if (T)
+    selection2.text((i) => formatDefault(T[i]));
 }
-function autoScaleRound(scale3) {
-  if (scale3.round === void 0 && isBandScale(scale3) && roundError(scale3) <= 30) {
-    scale3.scale.round(true);
-  }
+function applyTextGroup(selection2, T) {
+  if (T)
+    selection2.text(([i]) => formatDefault(T[i]));
 }
-function roundError({ scale: scale3 }) {
-  const n = scale3.domain().length;
-  const [start2, stop] = scale3.range();
-  const paddingInner = scale3.paddingInner ? scale3.paddingInner() : 1;
-  const paddingOuter = scale3.paddingOuter ? scale3.paddingOuter() : scale3.padding();
-  const m = n - paddingInner;
-  const step = Math.abs(stop - start2) / Math.max(1, m + paddingOuter * 2);
-  return (step - Math.floor(step)) * m;
+function applyChannelStyles(selection2, { target, tip: tip2 }, {
+  ariaLabel: AL,
+  title: T,
+  fill: F,
+  fillOpacity: FO,
+  stroke: S,
+  strokeOpacity: SO,
+  strokeWidth: SW,
+  opacity: O,
+  href: H
+}) {
+  if (AL)
+    applyAttr(selection2, "aria-label", (i) => AL[i]);
+  if (F)
+    applyAttr(selection2, "fill", (i) => F[i]);
+  if (FO)
+    applyAttr(selection2, "fill-opacity", (i) => FO[i]);
+  if (S)
+    applyAttr(selection2, "stroke", (i) => S[i]);
+  if (SO)
+    applyAttr(selection2, "stroke-opacity", (i) => SO[i]);
+  if (SW)
+    applyAttr(selection2, "stroke-width", (i) => SW[i]);
+  if (O)
+    applyAttr(selection2, "opacity", (i) => O[i]);
+  if (H)
+    applyHref(selection2, (i) => H[i], target);
+  if (!tip2)
+    applyTitle(selection2, T);
 }
-function piecewiseRange(scale3) {
-  const length4 = scale3.scale.domain().length + isThresholdScale(scale3);
-  if (!(length4 > 2))
-    return scale3.range;
-  const [start2, end] = scale3.range;
-  return Array.from({ length: length4 }, (_, i) => start2 + i / (length4 - 1) * (end - start2));
+function applyGroupedChannelStyles(selection2, { target, tip: tip2 }, {
+  ariaLabel: AL,
+  title: T,
+  fill: F,
+  fillOpacity: FO,
+  stroke: S,
+  strokeOpacity: SO,
+  strokeWidth: SW,
+  opacity: O,
+  href: H
+}) {
+  if (AL)
+    applyAttr(selection2, "aria-label", ([i]) => AL[i]);
+  if (F)
+    applyAttr(selection2, "fill", ([i]) => F[i]);
+  if (FO)
+    applyAttr(selection2, "fill-opacity", ([i]) => FO[i]);
+  if (S)
+    applyAttr(selection2, "stroke", ([i]) => S[i]);
+  if (SO)
+    applyAttr(selection2, "stroke-opacity", ([i]) => SO[i]);
+  if (SW)
+    applyAttr(selection2, "stroke-width", ([i]) => SW[i]);
+  if (O)
+    applyAttr(selection2, "opacity", ([i]) => O[i]);
+  if (H)
+    applyHref(selection2, ([i]) => H[i], target);
+  if (!tip2)
+    applyTitleGroup(selection2, T);
 }
-function normalizeScale(key, scale3, hint) {
-  return createScale(key, hint === void 0 ? void 0 : [{ hint }], { ...scale3 });
+function groupAesthetics({
+  ariaLabel: AL,
+  title: T,
+  fill: F,
+  fillOpacity: FO,
+  stroke: S,
+  strokeOpacity: SO,
+  strokeWidth: SW,
+  opacity: O,
+  href: H
+}, { tip: tip2 }) {
+  return [AL, tip2 ? void 0 : T, F, FO, S, SO, SW, O, H].filter((c4) => c4 !== void 0);
 }
-function createScale(key, channels = [], options = {}) {
-  const type2 = inferScaleType(key, channels, options);
-  if (options.type === void 0 && options.domain === void 0 && options.range === void 0 && options.interval == null && key !== "fx" && key !== "fy" && isOrdinalScale({ type: type2 })) {
-    const values2 = channels.map(({ value }) => value).filter((value) => value !== void 0);
-    if (values2.some(isTemporal))
-      warn(
-        `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType(
-          type2
-        )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
-          type2
-        )}".`
-      );
-    else if (values2.some(isTemporalString))
-      warn(
-        `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType(
-          type2
-        )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
-          type2
-        )}".`
-      );
-    else if (values2.some(isNumericString))
-      warn(
-        `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType(
-          type2
-        )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType(
-          type2
-        )}".`
-      );
+function groupZ2(I, Z, z) {
+  const G = group(I, (i) => Z[i]);
+  if (z === void 0 && G.size > 1 + I.length >> 1) {
+    warn(
+      `Warning: the implicit z channel has high cardinality. This may occur when the fill or stroke channel is associated with quantitative data rather than ordinal or categorical data. You can suppress this warning by setting the z option explicitly; if this data represents a single series, set z to null.`
+    );
   }
-  options.type = type2;
-  switch (type2) {
-    case "diverging":
-    case "diverging-sqrt":
-    case "diverging-pow":
-    case "diverging-log":
-    case "diverging-symlog":
-    case "cyclical":
-    case "sequential":
-    case "linear":
-    case "sqrt":
-    case "threshold":
-    case "quantile":
-    case "pow":
-    case "log":
-    case "symlog":
-      options = coerceType(channels, options, coerceNumbers);
-      break;
-    case "identity":
-      switch (registry.get(key)) {
-        case position:
-          options = coerceType(channels, options, coerceNumbers);
-          break;
-        case symbol:
-          options = coerceType(channels, options, coerceSymbols);
-          break;
+  return G.values();
+}
+function* groupIndex(I, position3, mark, channels) {
+  const { z } = mark;
+  const { z: Z } = channels;
+  const A5 = groupAesthetics(channels, mark);
+  const C3 = [...position3, ...A5];
+  for (const G of Z ? groupZ2(I, Z, z) : [I]) {
+    let Ag;
+    let Gg;
+    out:
+      for (const i of G) {
+        for (const c4 of C3) {
+          if (!defined(c4[i])) {
+            if (Gg)
+              Gg.push(-1);
+            continue out;
+          }
+        }
+        if (Ag === void 0) {
+          if (Gg)
+            yield Gg;
+          Ag = A5.map((c4) => keyof2(c4[i])), Gg = [i];
+          continue;
+        }
+        Gg.push(i);
+        for (let j = 0; j < A5.length; ++j) {
+          const k2 = keyof2(A5[j][i]);
+          if (k2 !== Ag[j]) {
+            yield Gg;
+            Ag = A5.map((c4) => keyof2(c4[i])), Gg = [i];
+            continue out;
+          }
+        }
       }
+    if (Gg)
+      yield Gg;
+  }
+}
+function applyClip(selection2, mark, dimensions, context) {
+  let clipUrl;
+  const { clip = context.clip } = mark;
+  switch (clip) {
+    case "frame": {
+      const { width, height, marginLeft, marginRight, marginTop, marginBottom } = dimensions;
+      const id2 = getClipId();
+      clipUrl = `url(#${id2})`;
+      selection2 = create3("svg:g", context).call(
+        (g) => g.append("svg:clipPath").attr("id", id2).append("rect").attr("x", marginLeft).attr("y", marginTop).attr("width", width - marginRight - marginLeft).attr("height", height - marginTop - marginBottom)
+      ).each(function() {
+        this.appendChild(selection2.node());
+        selection2.node = () => this;
+      });
       break;
-    case "utc":
-    case "time":
-      options = coerceType(channels, options, coerceDates);
+    }
+    case "sphere": {
+      const { projection: projection3 } = context;
+      if (!projection3)
+        throw new Error(`the "sphere" clip option requires a projection`);
+      const id2 = getClipId();
+      clipUrl = `url(#${id2})`;
+      selection2.append("clipPath").attr("id", id2).append("path").attr("d", path_default(projection3)({ type: "Sphere" }));
       break;
+    }
   }
-  switch (type2) {
-    case "diverging":
-      return createScaleDiverging(key, channels, options);
-    case "diverging-sqrt":
-      return createScaleDivergingSqrt(key, channels, options);
-    case "diverging-pow":
-      return createScaleDivergingPow(key, channels, options);
-    case "diverging-log":
-      return createScaleDivergingLog(key, channels, options);
-    case "diverging-symlog":
-      return createScaleDivergingSymlog(key, channels, options);
-    case "categorical":
-    case "ordinal":
-    case ordinalImplicit:
-      return createScaleOrdinal(key, channels, options);
-    case "cyclical":
-    case "sequential":
-    case "linear":
-      return createScaleLinear(key, channels, options);
-    case "sqrt":
-      return createScaleSqrt(key, channels, options);
-    case "threshold":
-      return createScaleThreshold(key, channels, options);
-    case "quantile":
-      return createScaleQuantile(key, channels, options);
-    case "quantize":
-      return createScaleQuantize(key, channels, options);
-    case "pow":
-      return createScalePow(key, channels, options);
-    case "log":
-      return createScaleLog(key, channels, options);
-    case "symlog":
-      return createScaleSymlog(key, channels, options);
-    case "utc":
-      return createScaleUtc(key, channels, options);
-    case "time":
-      return createScaleTime(key, channels, options);
-    case "point":
-      return createScalePoint(key, channels, options);
-    case "band":
-      return createScaleBand(key, channels, options);
-    case "identity":
-      return createScaleIdentity(key);
-    case void 0:
-      return;
-    default:
-      throw new Error(`unknown scale type: ${type2}`);
-  }
-}
-function formatScaleType(type2) {
-  return typeof type2 === "symbol" ? type2.description : type2;
-}
-function maybeScaleType(type2) {
-  return typeof type2 === "string" ? `${type2}`.toLowerCase() : type2;
+  applyAttr(selection2, "aria-label", mark.ariaLabel);
+  applyAttr(selection2, "aria-description", mark.ariaDescription);
+  applyAttr(selection2, "aria-hidden", mark.ariaHidden);
+  applyAttr(selection2, "clip-path", clipUrl);
 }
-var typeProjection = { toString: () => "projection" };
-function inferScaleType(key, channels, { type: type2, domain, range: range3, scheme: scheme28, pivot, projection: projection3 }) {
-  type2 = maybeScaleType(type2);
-  if (key === "fx" || key === "fy")
-    return "band";
-  if ((key === "x" || key === "y") && projection3 != null)
-    type2 = typeProjection;
-  for (const channel of channels) {
-    const t = maybeScaleType(channel.type);
-    if (t === void 0)
-      continue;
-    else if (type2 === void 0)
-      type2 = t;
-    else if (type2 !== t)
-      throw new Error(`scale incompatible with channel: ${type2} !== ${t}`);
-  }
-  if (type2 === typeProjection)
-    return;
-  if (type2 !== void 0)
-    return type2;
-  if (domain === void 0 && !channels.some(({ value }) => value !== void 0))
-    return;
-  const kind = registry.get(key);
-  if (kind === radius)
-    return "sqrt";
-  if (kind === opacity || kind === length3)
-    return "linear";
-  if (kind === symbol)
-    return "ordinal";
-  if ((domain || range3 || []).length > 2)
-    return asOrdinalType(kind);
-  if (domain !== void 0) {
-    if (isOrdinal(domain))
-      return asOrdinalType(kind);
-    if (isTemporal(domain))
-      return "utc";
-  } else {
-    const values2 = channels.map(({ value }) => value).filter((value) => value !== void 0);
-    if (values2.some(isOrdinal))
-      return asOrdinalType(kind);
-    if (values2.some(isTemporal))
-      return "utc";
-  }
-  if (kind === color2) {
-    if (pivot != null || isDivergingScheme(scheme28))
-      return "diverging";
-    if (isCategoricalScheme(scheme28))
-      return "categorical";
-  }
-  return "linear";
+function applyIndirectStyles(selection2, mark, dimensions, context) {
+  applyClip(selection2, mark, dimensions, context);
+  applyAttr(selection2, "fill", mark.fill);
+  applyAttr(selection2, "fill-opacity", mark.fillOpacity);
+  applyAttr(selection2, "stroke", mark.stroke);
+  applyAttr(selection2, "stroke-width", mark.strokeWidth);
+  applyAttr(selection2, "stroke-opacity", mark.strokeOpacity);
+  applyAttr(selection2, "stroke-linejoin", mark.strokeLinejoin);
+  applyAttr(selection2, "stroke-linecap", mark.strokeLinecap);
+  applyAttr(selection2, "stroke-miterlimit", mark.strokeMiterlimit);
+  applyAttr(selection2, "stroke-dasharray", mark.strokeDasharray);
+  applyAttr(selection2, "stroke-dashoffset", mark.strokeDashoffset);
+  applyAttr(selection2, "shape-rendering", mark.shapeRendering);
+  applyAttr(selection2, "filter", mark.imageFilter);
+  applyAttr(selection2, "paint-order", mark.paintOrder);
+  const { pointerEvents = context.pointerSticky === false ? "none" : void 0 } = mark;
+  applyAttr(selection2, "pointer-events", pointerEvents);
 }
-function asOrdinalType(kind) {
-  switch (kind) {
-    case position:
-      return "point";
-    case color2:
-      return ordinalImplicit;
-    default:
-      return "ordinal";
-  }
+function applyDirectStyles(selection2, mark) {
+  applyStyle(selection2, "mix-blend-mode", mark.mixBlendMode);
+  applyAttr(selection2, "opacity", mark.opacity);
 }
-function isOrdinalScale({ type: type2 }) {
-  return type2 === "ordinal" || type2 === "point" || type2 === "band" || type2 === ordinalImplicit;
+function applyHref(selection2, href, target) {
+  selection2.each(function(i) {
+    const h = href(i);
+    if (h != null) {
+      const a2 = this.ownerDocument.createElementNS(namespaces_default.svg, "a");
+      a2.setAttribute("fill", "inherit");
+      a2.setAttributeNS(namespaces_default.xlink, "href", h);
+      if (target != null)
+        a2.setAttribute("target", target);
+      this.parentNode.insertBefore(a2, this).appendChild(this);
+    }
+  });
 }
-function isThresholdScale({ type: type2 }) {
-  return type2 === "threshold";
+function applyAttr(selection2, name, value) {
+  if (value != null)
+    selection2.attr(name, value);
 }
-function isBandScale({ type: type2 }) {
-  return type2 === "point" || type2 === "band";
+function applyStyle(selection2, name, value) {
+  if (value != null)
+    selection2.style(name, value);
 }
-function isCollapsed(scale3) {
-  if (scale3 === void 0)
-    return true;
-  const domain = scale3.domain();
-  const value = scale3(domain[0]);
-  for (let i = 1, n = domain.length; i < n; ++i) {
-    if (scale3(domain[i]) - value) {
-      return false;
-    }
-  }
-  return true;
+function applyTransform(selection2, mark, { x: x3, y: y3 }, tx = offset, ty = offset) {
+  tx += mark.dx;
+  ty += mark.dy;
+  if (x3?.bandwidth)
+    tx += x3.bandwidth() / 2;
+  if (y3?.bandwidth)
+    ty += y3.bandwidth() / 2;
+  if (tx || ty)
+    selection2.attr("transform", `translate(${tx},${ty})`);
 }
-function coerceType(channels, { domain, ...options }, coerceValues) {
-  for (const c4 of channels) {
-    if (c4.value !== void 0) {
-      if (domain === void 0)
-        domain = c4.value?.domain;
-      c4.value = coerceValues(c4.value);
-    }
-  }
-  return {
-    domain: domain === void 0 ? domain : coerceValues(domain),
-    ...options
-  };
+function impliedString(value, impliedValue) {
+  if ((value = string(value)) !== impliedValue)
+    return value;
 }
-function coerceSymbols(values2) {
-  return map2(values2, maybeSymbol);
+function impliedNumber(value, impliedValue) {
+  if ((value = number5(value)) !== impliedValue)
+    return value;
 }
-function scale2(options = {}) {
-  let scale3;
-  for (const key in options) {
-    if (!registry.has(key))
-      continue;
-    if (!isScaleOptions(options[key]))
-      continue;
-    if (scale3 !== void 0)
-      throw new Error("ambiguous scale definition; multiple scales found");
-    scale3 = exposeScale(normalizeScale(key, options[key]));
-  }
-  if (scale3 === void 0)
-    throw new Error("invalid scale definition; no scale found");
-  return scale3;
+var validClassName = /^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i;
+function maybeClassName(name) {
+  if (name === void 0)
+    return "plot-d6a7b5";
+  name = `${name}`;
+  if (!validClassName.test(name))
+    throw new Error(`invalid class name: ${name}`);
+  return name;
 }
-function exposeScales(scales2) {
-  return (key) => {
-    if (!registry.has(key = `${key}`))
-      throw new Error(`unknown scale: ${key}`);
-    return scales2[key];
-  };
+function applyInlineStyles(selection2, style) {
+  if (typeof style === "string") {
+    selection2.property("style", style);
+  } else if (style != null) {
+    for (const element of selection2) {
+      Object.assign(element.style, style);
+    }
+  }
 }
-function exposeScale({ scale: scale3, type: type2, domain, range: range3, interpolate, interval: interval2, transform: transform3, percent, pivot }) {
-  if (type2 === "identity")
-    return { type: "identity", apply: (d) => d, invert: (d) => d };
-  const unknown = scale3.unknown ? scale3.unknown() : void 0;
-  return {
-    type: type2,
-    domain: slice3(domain),
-    // defensive copy
-    ...range3 !== void 0 && { range: slice3(range3) },
-    // defensive copy
-    ...transform3 !== void 0 && { transform: transform3 },
-    ...percent && { percent },
-    // only exposed if truthy
-    ...unknown !== void 0 && { unknown },
-    ...interval2 !== void 0 && { interval: interval2 },
-    // quantitative
-    ...interpolate !== void 0 && { interpolate },
-    ...scale3.clamp && { clamp: scale3.clamp() },
-    // diverging (always asymmetric; we never want to apply the symmetric transform twice)
-    ...pivot !== void 0 && { pivot, symmetric: false },
-    // log, diverging-log
-    ...scale3.base && { base: scale3.base() },
-    // pow, diverging-pow
-    ...scale3.exponent && { exponent: scale3.exponent() },
-    // symlog, diverging-symlog
-    ...scale3.constant && { constant: scale3.constant() },
-    // band, point
-    ...scale3.align && { align: scale3.align(), round: scale3.round() },
-    ...scale3.padding && (scale3.paddingInner ? { paddingInner: scale3.paddingInner(), paddingOuter: scale3.paddingOuter() } : { padding: scale3.padding() }),
-    ...scale3.bandwidth && { bandwidth: scale3.bandwidth(), step: scale3.step() },
-    // utilities
-    apply: (t) => scale3(t),
-    ...scale3.invert && { invert: (t) => scale3.invert(t) }
-  };
+function applyFrameAnchor({ frameAnchor }, { width, height, marginTop, marginRight, marginBottom, marginLeft }) {
+  return [
+    /left$/.test(frameAnchor) ? marginLeft : /right$/.test(frameAnchor) ? width - marginRight : (marginLeft + width - marginRight) / 2,
+    /^top/.test(frameAnchor) ? marginTop : /^bottom/.test(frameAnchor) ? height - marginBottom : (marginTop + height - marginBottom) / 2
+  ];
 }
 
 // ../../node_modules/@observablehq/plot/src/dimensions.js
@@ -33081,19 +33163,28 @@ function axisTickKy(k2, anchor, data, {
   y: y3 = k2 === "y" ? void 0 : null,
   ...options
 }) {
-  return axisMark(vectorY, k2, anchor, `${k2}-axis tick`, data, {
-    strokeWidth,
-    strokeLinecap,
-    strokeLinejoin,
-    facetAnchor,
-    frameAnchor,
-    y: y3,
-    ...options,
-    dx: anchor === "left" ? +dx - offset + +insetLeft : +dx + offset - insetRight,
-    anchor: "start",
-    length: tickSize,
-    shape: anchor === "left" ? shapeTickLeft : shapeTickRight
-  });
+  return axisMark(
+    vectorY,
+    k2,
+    data,
+    {
+      ariaLabel: `${k2}-axis tick`,
+      ariaHidden: true
+    },
+    {
+      strokeWidth,
+      strokeLinecap,
+      strokeLinejoin,
+      facetAnchor,
+      frameAnchor,
+      y: y3,
+      ...options,
+      dx: anchor === "left" ? +dx - offset + +insetLeft : +dx + offset - insetRight,
+      anchor: "start",
+      length: tickSize,
+      shape: anchor === "left" ? shapeTickLeft : shapeTickRight
+    }
+  );
 }
 function axisTickKx(k2, anchor, data, {
   strokeWidth = 1,
@@ -33109,19 +33200,28 @@ function axisTickKx(k2, anchor, data, {
   x: x3 = k2 === "x" ? void 0 : null,
   ...options
 }) {
-  return axisMark(vectorX, k2, anchor, `${k2}-axis tick`, data, {
-    strokeWidth,
-    strokeLinejoin,
-    strokeLinecap,
-    facetAnchor,
-    frameAnchor,
-    x: x3,
-    ...options,
-    dy: anchor === "bottom" ? +dy - offset - insetBottom : +dy + offset + +insetTop,
-    anchor: "start",
-    length: tickSize,
-    shape: anchor === "bottom" ? shapeTickBottom : shapeTickTop
-  });
+  return axisMark(
+    vectorX,
+    k2,
+    data,
+    {
+      ariaLabel: `${k2}-axis tick`,
+      ariaHidden: true
+    },
+    {
+      strokeWidth,
+      strokeLinejoin,
+      strokeLinecap,
+      facetAnchor,
+      frameAnchor,
+      x: x3,
+      ...options,
+      dy: anchor === "bottom" ? +dy - offset - insetBottom : +dy + offset + +insetTop,
+      anchor: "start",
+      length: tickSize,
+      shape: anchor === "bottom" ? shapeTickBottom : shapeTickTop
+    }
+  );
 }
 function axisTextKy(k2, anchor, data, {
   facetAnchor = anchor + (k2 === "y" ? "-empty" : ""),
@@ -33143,9 +33243,8 @@ function axisTextKy(k2, anchor, data, {
   return axisMark(
     textY,
     k2,
-    anchor,
-    `${k2}-axis tick label`,
     data,
+    { ariaLabel: `${k2}-axis tick label` },
     {
       facetAnchor,
       frameAnchor,
@@ -33186,9 +33285,8 @@ function axisTextKx(k2, anchor, data, {
   return axisMark(
     textX,
     k2,
-    anchor,
-    `${k2}-axis tick label`,
     data,
+    { ariaLabel: `${k2}-axis tick label` },
     {
       facetAnchor,
       frameAnchor,
@@ -33232,7 +33330,7 @@ function gridKy(k2, anchor, data, {
   x2: x22 = anchor === "right" ? x3 : null,
   ...options
 }) {
-  return axisMark(ruleY, k2, anchor, `${k2}-grid`, data, { y: y3, x1: x12, x2: x22, ...gridDefaults(options) });
+  return axisMark(ruleY, k2, data, { ariaLabel: `${k2}-grid`, ariaHidden: true }, { y: y3, x1: x12, x2: x22, ...gridDefaults(options) });
 }
 function gridKx(k2, anchor, data, {
   x: x3 = k2 === "x" ? void 0 : null,
@@ -33241,7 +33339,7 @@ function gridKx(k2, anchor, data, {
   y2: y22 = anchor === "bottom" ? y3 : null,
   ...options
 }) {
-  return axisMark(ruleX, k2, anchor, `${k2}-grid`, data, { x: x3, y1: y12, y2: y22, ...gridDefaults(options) });
+  return axisMark(ruleX, k2, data, { ariaLabel: `${k2}-grid`, ariaHidden: true }, { x: x3, y1: y12, y2: y22, ...gridDefaults(options) });
 }
 function gridDefaults({
   color: color3 = "currentColor",
@@ -33286,7 +33384,7 @@ function labelOptions({
     initializer: initializer2
   };
 }
-function axisMark(mark, k2, anchor, ariaLabel, data, options, initialize) {
+function axisMark(mark, k2, data, properties, options, initialize) {
   let channels;
   function axisInitializer(data2, facets, _channels, scales2, dimensions, context) {
     const initializeFacets = data2 == null && (k2 === "fx" || k2 === "fy");
@@ -33358,7 +33456,8 @@ function axisMark(mark, k2, anchor, ariaLabel, data, options, initialize) {
   } else {
     channels = {};
   }
-  m.ariaLabel = ariaLabel;
+  if (properties !== void 0)
+    Object.assign(m, properties);
   if (m.clip === void 0)
     m.clip = false;
   return m;
@@ -34787,6 +34886,8 @@ function binn(bx, by, gx, gy, {
         for (const [f, I] of maybeGroup(facet, G)) {
           for (const [k3, g] of maybeGroup(I, K2)) {
             for (const [b, extent4] of bin3(g)) {
+              if (G)
+                extent4.z = f;
               if (filter3 && !filter3.reduce(b, extent4))
                 continue;
               groupFacet.push(i++);
@@ -34806,7 +34907,7 @@ function binn(bx, by, gx, gy, {
               for (const o of outputs)
                 o.reduce(b, extent4);
               if (sort3)
-                sort3.reduce(b);
+                sort3.reduce(b, extent4);
             }
           }
         }
@@ -34973,6 +35074,8 @@ function maybeBinReduceFallback(reduce) {
       return reduceY1;
     case "y2":
       return reduceY22;
+    case "z":
+      return reduceZ;
   }
   throw new Error(`invalid bin reduce: ${reduce}`);
 }
@@ -39643,13 +39746,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 +39822,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 +39844,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 +39886,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 +40093,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 +40108,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 +40193,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 +40209,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 +40295,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 +40333,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 +40359,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 +40379,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 +40417,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 +40919,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 +41264,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 +41465,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 +41759,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 +42308,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 +42343,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 +42411,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 +42548,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 +42778,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 +42810,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 +42820,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})`;