ggaction 0.0.9 → 0.0.11

package/src/core/textMetrics.js

@@ -1,38 +1,69 @@
 function codePointWidth(codePoint) {
   if (/\s/u.test(codePoint)) return 0.28;
-  if (/[iIl1.,:;!'|]/u.test(codePoint)) return 0.27;
+  if (/[iIl.,:;!'|]/u.test(codePoint)) return 0.27;
   if (/[mwMW@#%&]/u.test(codePoint)) return 0.82;
-  if (/[A-Z]/u.test(codePoint)) return 0.61;
-  if (/[0-9]/u.test(codePoint)) return 0.53;
+  if (/[A-Z0-9]/u.test(codePoint)) return 0.61;
   if (/[-_]/u.test(codePoint)) return 0.34;
   if (codePoint.codePointAt(0) > 0x7f) return 1;
   return 0.47;
 }
 
-export function measureTextWidth(text, { fontSize } = {}) {
+export function formatVisibleText(value) {
+  return String(value) || "(empty)";
+}
+
+export function textBoundsIntersect(first, second) {
+  return first.left < second.right && first.right > second.left &&
+    first.top < second.bottom && first.bottom > second.top;
+}
+
+export function textBoundsFitCanvas(bounds, canvas) {
+  const epsilon = 1e-9;
+  return bounds.left >= -epsilon && bounds.right <= canvas.width + epsilon &&
+    bounds.top >= -epsilon && bounds.bottom <= canvas.height + epsilon;
+}
+
+export function measureTextWidth(
+  text,
+  { fontSize, fontFamily, fontWeight } = {}
+) {
   if (typeof text !== "string") {
     throw new TypeError("Text measurement requires a string.");
   }
   if (!Number.isFinite(fontSize) || fontSize <= 0) {
     throw new RangeError("Text measurement requires a positive fontSize.");
   }
-  return [...text].reduce(
-    (width, codePoint) => width + codePointWidth(codePoint) * fontSize,
-    0
-  );
-}
-
-function horizontalExtents(width, align) {
-  if (align === "center") return [-width / 2, width / 2];
-  if (["right", "end"].includes(align)) return [-width, 0];
-  return [0, width];
+  let joined = false;
+  let width = 0;
+  for (const codePoint of text) {
+    if (codePoint === "\u200d") {
+      joined = true;
+    } else if (!/\p{Mark}|\p{Format}|\p{Emoji_Modifier}/u.test(codePoint)) {
+      if (joined) joined = false;
+      else width += codePointWidth(codePoint) * fontSize;
+    }
+  }
+  const family = typeof fontFamily === "string" ? fontFamily.toLowerCase() : "";
+  const familyFactor = /mono/u.test(family)
+    ? 1.08
+    : /serif/u.test(family) && !/sans-serif/u.test(family) ? 1.03 : 1;
+  const weight = Number(fontWeight);
+  width *= familyFactor * ((
+    Number.isFinite(weight)
+      ? weight >= 600
+      : /bold|black|heavy/iu.test(fontWeight ?? "")
+  ) ? 1.04 : 1);
+  if (!Number.isFinite(width)) {
+    throw new RangeError("Text measurement exceeds the finite numeric range.");
+  }
+  return width;
 }
 
-function verticalExtents(fontSize, baseline) {
-  if (baseline === "middle") return [-fontSize / 2, fontSize / 2];
-  if (["top", "hanging"].includes(baseline)) return [0, fontSize];
-  if (["bottom", "ideographic"].includes(baseline)) return [-fontSize, 0];
-  return [-fontSize * 0.8, fontSize * 0.2];
+export function requireFiniteBounds(bounds, label = "Graphic") {
+  if (bounds !== undefined && !Object.values(bounds).every(Number.isFinite)) {
+    throw new RangeError(`${label} bounds exceed the finite numeric range.`);
+  }
+  return bounds;
 }
 
 export function resolveTextBounds({
@@ -40,6 +71,8 @@ export function resolveTextBounds({
   y,
   text,
   fontSize,
+  fontFamily,
+  fontWeight,
   textAlign = "left",
   textBaseline = "alphabetic",
   rotation = 0
@@ -47,24 +80,28 @@ export function resolveTextBounds({
   if (![x, y, rotation].every(Number.isFinite)) {
     throw new TypeError("Text bounds require finite x, y, and rotation values.");
   }
-  const width = measureTextWidth(text, { fontSize });
-  const [left, right] = horizontalExtents(width, textAlign);
-  const [top, bottom] = verticalExtents(fontSize, textBaseline);
+  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight });
+  const [left, right] = textAlign === "center"
+    ? [-width / 2, width / 2]
+    : ["right", "end"].includes(textAlign) ? [-width, 0] : [0, width];
+  const [top, bottom] = textBaseline === "middle"
+    ? [-fontSize / 2, fontSize / 2]
+    : ["top", "hanging"].includes(textBaseline)
+      ? [0, fontSize]
+      : ["bottom", "ideographic"].includes(textBaseline)
+        ? [-fontSize, 0]
+        : [-fontSize * 0.8, fontSize * 0.2];
   const cosine = Math.cos(rotation);
   const sine = Math.sin(rotation);
-  const corners = [
-    [left, top],
-    [right, top],
-    [right, bottom],
-    [left, bottom]
-  ].map(([localX, localY]) => ({
-    x: x + localX * cosine - localY * sine,
-    y: y + localX * sine + localY * cosine
-  }));
-  return Object.freeze({
-    left: Math.min(...corners.map(point => point.x)),
-    right: Math.max(...corners.map(point => point.x)),
-    top: Math.min(...corners.map(point => point.y)),
-    bottom: Math.max(...corners.map(point => point.y))
-  });
+  const bounds = {
+    left: x + Math.min(left * cosine, right * cosine) -
+      Math.max(top * sine, bottom * sine),
+    right: x + Math.max(left * cosine, right * cosine) -
+      Math.min(top * sine, bottom * sine),
+    top: y + Math.min(left * sine, right * sine) +
+      Math.min(top * cosine, bottom * cosine),
+    bottom: y + Math.max(left * sine, right * sine) +
+      Math.max(top * cosine, bottom * cosine)
+  };
+  return Object.freeze(requireFiniteBounds(bounds, "Text"));
 }

package/src/core/validation.js

@@ -1,5 +1,23 @@
 import { isPlainObject } from "./immutable.js";
 
+export const MAX_GENERATED_ITEMS = 10_000;
+export const MAX_WORK_ITEMS = 10_000_000;
+
+export function validateGeneratedItemLimit(
+  value,
+  label,
+  maximum = MAX_GENERATED_ITEMS
+) {
+  if (value > maximum) {
+    throw new RangeError(`${label} must not exceed ${maximum}.`);
+  }
+  return value;
+}
+
+export function validateWorkLimit(value, label) {
+  return validateGeneratedItemLimit(value, label, MAX_WORK_ITEMS);
+}
+
 export function validateKeys(value, supported, label) {
   for (const key of Object.keys(value)) {
     if (!supported.includes(key)) {

package/src/extension.js

@@ -1,2 +1,9 @@
 export { action } from "./core/action.js";
-export { ChartProgram } from "./ChartProgram.js";
+import { ChartProgram } from "./ChartProgram.js";
+import { registerProgramExtension } from "./core/extensionRegistry.js";
+
+export { ChartProgram };
+
+export function registerExtension(definition) {
+  registerProgramExtension(ChartProgram, definition);
+}

package/src/grammar/aggregate.js

@@ -1,4 +1,12 @@
 import { isPlainObject } from "../core/immutable.js";
+import {
+  interpolateNumber,
+  numericExtent,
+  requireFiniteResult,
+  stableFiniteDeviation,
+  stableFiniteMean,
+  stableFiniteSum
+} from "./numeric.js";
 
 export const SCALAR_AGGREGATE_OPERATIONS = Object.freeze([
   "count", "sum", "mean", "median", "min", "max",
@@ -8,8 +16,8 @@ export const SCALAR_AGGREGATE_OPERATIONS = Object.freeze([
 ]);
 
 const SCALAR_OPERATIONS = new Set(SCALAR_AGGREGATE_OPERATIONS);
-const NOMINAL_OPERATIONS = new Set(["count", "distinct", "valid", "missing"]);
-const PARAMETERIZED_OPERATIONS = new Set(["quantile", "first", "last"]);
+const NOMINAL_OPERATIONS = ["count", "distinct", "valid", "missing"];
+const PARAMETERIZED_OPERATIONS = ["quantile", "first", "last"];
 
 function nonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -22,7 +30,7 @@ export function isScalarAggregate(value) {
 }
 
 export function isParameterizedAggregate(value) {
-  return isPlainObject(value) && PARAMETERIZED_OPERATIONS.has(value.op);
+  return isPlainObject(value) && PARAMETERIZED_OPERATIONS.includes(value.op);
 }
 
 export function isAggregate(value) {
@@ -95,7 +103,7 @@ export function validateScalarAggregateFieldType(operation, fieldType) {
     throw new Error("Scalar aggregate calculation requires a scalar operation.");
   }
   if (fieldType === "quantitative") return fieldType;
-  if (fieldType === "nominal" && NOMINAL_OPERATIONS.has(operation)) {
+  if (fieldType === "nominal" && NOMINAL_OPERATIONS.includes(operation)) {
     return fieldType;
   }
   throw new Error(
@@ -139,8 +147,11 @@ function quantile(values, probability) {
   const position = (ordered.length - 1) * probability;
   const lower = Math.floor(position);
   const upper = Math.ceil(position);
-  return ordered[lower] +
-    (ordered[upper] - ordered[lower]) * (position - lower);
+  return interpolateNumber(
+    ordered[lower],
+    ordered[upper],
+    position - lower
+  );
 }
 
 function comparableOrderKey(value) {
@@ -179,15 +190,6 @@ function aggregateOrderedRows(rows, field, aggregate) {
     : candidates.at(-1).value;
 }
 
-function moments(values) {
-  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
-  const squared = values.reduce(
-    (sum, value) => sum + (value - mean) ** 2,
-    0
-  );
-  return { mean, squared };
-}
-
 export function aggregateScalarValues(values, operation) {
   if (!Array.isArray(values)) {
     throw new TypeError("Aggregate values must be an array.");
@@ -206,27 +208,45 @@ export function aggregateScalarValues(values, operation) {
   const finite = finiteValues(values);
   if (finite.length === 0) return undefined;
   if (operation === "sum") {
-    return finite.reduce((sum, value) => sum + value, 0);
+    return stableFiniteSum(finite, "Aggregate sum");
   }
-  if (operation === "min") return Math.min(...finite);
-  if (operation === "max") return Math.max(...finite);
+  if (operation === "min") return numericExtent(finite)[0];
+  if (operation === "max") return numericExtent(finite)[1];
   if (operation === "median") return quantile(finite, 0.5);
   if (operation === "q1") return quantile(finite, 0.25);
   if (operation === "q3") return quantile(finite, 0.75);
 
-  const { mean, squared } = moments(finite);
+  const mean = stableFiniteMean(finite, "Aggregate mean");
   if (operation === "mean") return mean;
-  if (operation === "varianceP") return squared / finite.length;
-  if (operation === "stdevP") return Math.sqrt(squared / finite.length);
+  if (["variance", "varianceP", "stdev", "stdevP"].includes(operation)) {
+    const population = operation.endsWith("P");
+    if (!population && finite.length < 2) return undefined;
+    const kind = population ? "population" : "sample";
+    const deviation = stableFiniteDeviation(finite, {
+      sample: !population,
+      label: `Aggregate ${kind} deviation`
+    });
+    if (operation.startsWith("stdev")) return deviation.deviation;
+    return deviation.squared === undefined
+      ? requireFiniteResult(
+          deviation.deviation ** 2,
+          `Aggregate ${kind} variance`
+        )
+      : deviation.squared / (finite.length - (population ? 0 : 1));
+  }
   if (finite.length < 2) return undefined;
-
-  const variance = squared / (finite.length - 1);
-  if (operation === "variance") return variance;
-  if (operation === "stdev") return Math.sqrt(variance);
-  const stderr = Math.sqrt(variance) / Math.sqrt(finite.length);
+  const stderr = stableFiniteDeviation(finite, {
+    sample: true,
+    divisor: Math.sqrt(finite.length),
+    label: "Aggregate standard error"
+  }).deviation;
   if (operation === "stderr") return stderr;
-  if (operation === "ciLower") return mean - 1.96 * stderr;
-  if (operation === "ciUpper") return mean + 1.96 * stderr;
+  if (operation === "ciLower") {
+    return requireFiniteResult(mean - 1.96 * stderr, "Aggregate lower CI");
+  }
+  if (operation === "ciUpper") {
+    return requireFiniteResult(mean + 1.96 * stderr, "Aggregate upper CI");
+  }
   throw new Error(`Unsupported scalar aggregate "${operation}".`);
 }
 

package/src/grammar/arcs.js

@@ -5,6 +5,12 @@ import {
   readNominalField,
   readQuantitativeField
 } from "./scales/index.js";
+import {
+  interpolateNumber,
+  normalizedFiniteSum,
+  requireFiniteResult,
+  stableFiniteSum
+} from "./numeric.js";
 
 function requireArcLayer(layer) {
   if (layer?.mark?.type !== "arc") {
@@ -22,6 +28,9 @@ function requireBandScale(scale, label) {
     scale?.type !== "band" ||
     !Array.isArray(scale.domain) ||
     !Array.isArray(scale.range) ||
+    scale.range.length !== 2 ||
+    !scale.range.every(Number.isFinite) ||
+    scale.range[0] === scale.range[1] ||
     !Number.isFinite(scale.bandwidth) ||
     scale.bandwidth <= 0
   ) {
@@ -73,31 +82,69 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
       throw new Error(`Arc theta value "${values[index]}" is outside the scale domain.`);
     }
     group.push({
-      row: rows[index],
       color: colors[index],
       sourceIndex: index,
       weight: weights[index]
     });
   }
-  const total = [...groups.values()].reduce(
-    (sum, group) => sum + group.reduce((groupSum, item) => groupSum + item.weight, 0),
-    0
+  if (!Number.isFinite(frame?.availableRadius) || frame.availableRadius < 0) {
+    throw new RangeError(`Arc mark "${layer.id}" requires a finite available radius.`);
+  }
+  const innerRadius = requireFiniteResult(
+    frame.availableRadius * innerRadiusRatio,
+    `Arc mark "${layer.id}" inner radius`
   );
-  if (total === 0) throw new Error(`Arc mark "${layer.id}" has no positive theta weight.`);
-  const start = thetaScale.range[0];
-  const span = thetaScale.range[1] - thetaScale.range[0];
-  const innerRadius = frame.availableRadius * innerRadiusRatio;
-  let cursor = start;
+  let cursor = thetaScale.range[0];
   const sectors = [];
   const positiveValues = thetaScale.domain.filter(value =>
     groups.get(value).some(item => item.weight > 0)
   );
+  const aggregateValues = positiveValues.map(value => stableFiniteSum(
+    groups.get(value).map(item => item.weight),
+    `Arc theta group "${String(value)}" aggregate`
+  ));
+  const total = aggregateValues.reduce((sum, value) => sum + value, 0);
+  const normalizedTotal = Number.isFinite(total)
+    ? undefined
+    : normalizedFiniteSum(
+        aggregateValues,
+        `Arc mark "${layer.id}" theta aggregates`
+      );
+  if (total === 0 || normalizedTotal?.total <= 0) {
+    throw new Error(`Arc mark "${layer.id}" has no positive theta weight.`);
+  }
+  const span = thetaScale.range[1] - thetaScale.range[0];
+  let cumulative = 0;
+  let cumulativeCorrection = 0;
   for (const [positiveIndex, value] of positiveValues.entries()) {
     const group = groups.get(value);
-    const aggregateValue = group.reduce((sum, item) => sum + item.weight, 0);
+    const aggregateValue = aggregateValues[positiveIndex];
+    const normalizedValue = normalizedTotal === undefined
+      ? aggregateValue
+      : aggregateValue / normalizedTotal.scale;
+    const next = cumulative + normalizedValue;
+    if (normalizedTotal !== undefined) {
+      cumulativeCorrection += Math.abs(cumulative) >= Math.abs(normalizedValue)
+        ? cumulative - next + normalizedValue
+        : normalizedValue - next + cumulative;
+    }
+    cumulative = next;
+    const directEnd = cursor + aggregateValue / total * span;
     const endTheta = positiveIndex === positiveValues.length - 1
       ? thetaScale.range[1]
-      : cursor + aggregateValue / total * span;
+      : normalizedTotal === undefined && Number.isFinite(directEnd)
+        ? directEnd
+        : interpolateNumber(
+            thetaScale.range[0],
+            thetaScale.range[1],
+            (cumulative + cumulativeCorrection) /
+              (normalizedTotal?.total ?? total)
+          );
+    if (!Number.isFinite(endTheta) || endTheta === cursor) {
+      throw new RangeError(
+        `Arc theta group "${String(value)}" cannot resolve a distinct finite sector.`
+      );
+    }
     const distinctColors = [...new Set(group.map(item => item.color))];
     if (distinctColors.length > 1) {
       throw new Error(

package/src/grammar/areaSeries.js

@@ -11,6 +11,12 @@ import {
 import { stableOrderPathValues } from "./pathOrder.js";
 import { deriveCategoricalDensitySeries } from "./categoricalDensity.js";
 
+function indexSegments(segments) {
+  const indexed = [];
+  for (const segment of segments) indexed[segment.index] = segment;
+  return indexed;
+}
+
 export function deriveAreaSeries(rows, layer) {
   if (layer?.mark?.type !== "area") {
     throw new Error("Area series derivation requires a semantic area mark.");
@@ -187,15 +193,11 @@ export function deriveCenteredAreaSeries(rows, layer) {
   const valuesBySeries = groupOrder.map(() => []);
   for (const position of orderedPositions) {
     const partition = groupOrder.map(key => byGroup.get(key).get(position));
-    const segments = new Map(
-      layoutSeriesPartition(partition, "center").map(segment => [
-        segment.index,
-        segment
-      ])
-    );
-    let endpoint = -partition.reduce((sum, value) => sum + value, 0) / 2;
+    const resolvedSegments = layoutSeriesPartition(partition, "center");
+    const segments = indexSegments(resolvedSegments);
+    let endpoint = resolvedSegments[0]?.start ?? 0;
     for (let index = 0; index < groupOrder.length; index += 1) {
-      const segment = segments.get(index);
+      const segment = segments[index];
       valuesBySeries[index].push({
         x: position,
         y: partition[index],
@@ -331,17 +333,13 @@ export function layoutDensityAreaSeries(derived, layout = "overlay") {
       }
       return series.values[sample].y;
     });
-    const segments = new Map(
-      layoutSeriesPartition(densities, layout).map(segment => [
-        segment.index,
-        segment
-      ])
-    );
+    const resolvedSegments = layoutSeriesPartition(densities, layout);
+    const segments = indexSegments(resolvedSegments);
     let zeroThicknessEndpoint = layout === "center"
-      ? -densities.reduce((sum, value) => sum + value, 0) / 2
+      ? resolvedSegments[0]?.start ?? 0
       : 0;
     for (let index = 0; index < derived.series.length; index += 1) {
-      const segment = segments.get(index);
+      const segment = segments[index];
       valuesBySeries[index].push({
         x,
         lower: segment?.start ?? zeroThicknessEndpoint,

package/src/grammar/bin2d.js

@@ -2,25 +2,22 @@ import {
   cloneAndFreeze,
   isPlainObject
 } from "../core/immutable.js";
+import { validateNonEmptyString as requireField } from "../core/validation.js";
+import { interpolateNumber, numericExtent } from "./numeric.js";
+
+const MAX_AXIS_BINS = 10_000;
+const MAX_CELLS = 1_000_000;
 
 const TRANSFORM_KEYS = Object.freeze([
   "type", "x", "y", "bins", "extent", "includeEmpty", "members", "as",
   "resolved"
 ]);
-const BIN_KEYS = Object.freeze(["x", "y"]);
-const EXTENT_KEYS = Object.freeze(["x", "y"]);
+const AXIS_KEYS = Object.freeze(["x", "y"]);
 const FIELD_KEYS = Object.freeze(["x0", "x1", "y0", "y1", "count", "members"]);
 const RESOLVED_KEYS = Object.freeze([
   "extent", "edges", "eligibleCount", "occupiedCount"
 ]);
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function rejectUnknownKeys(value, supported, label) {
   const unknown = Object.keys(value).find(key => !supported.includes(key));
   if (unknown !== undefined) {
@@ -43,7 +40,7 @@ function normalizeBins(value) {
       "2D bin bins must be a positive integer or an object with x and y."
     );
   }
-  rejectUnknownKeys(value, BIN_KEYS, "2D bin bins");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin bins");
   return { x: value.x, y: value.y };
 }
 
@@ -51,9 +48,15 @@ function validateBins(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin bins must be an object.");
   }
-  rejectUnknownKeys(value, BIN_KEYS, "2D bin bins");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin bins");
   requirePositiveInteger(value.x, "2D bin x bins");
   requirePositiveInteger(value.y, "2D bin y bins");
+  if (value.x > MAX_AXIS_BINS || value.y > MAX_AXIS_BINS) {
+    throw new RangeError(`2D bin axes support at most ${MAX_AXIS_BINS} bins.`);
+  }
+  if (value.x * value.y > MAX_CELLS) {
+    throw new RangeError(`2D bin grids support at most ${MAX_CELLS} cells.`);
+  }
 }
 
 function normalizeRequestedExtent(value) {
@@ -61,7 +64,7 @@ function normalizeRequestedExtent(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin extent must be an object.");
   }
-  rejectUnknownKeys(value, EXTENT_KEYS, "2D bin extent");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin extent");
   return {
     x: value.x ?? "auto",
     y: value.y ?? "auto"
@@ -84,7 +87,7 @@ function validateRequestedExtent(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin extent must be an object.");
   }
-  rejectUnknownKeys(value, EXTENT_KEYS, "2D bin extent");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin extent");
   validateExtentValue(value.x, "2D bin x extent");
   validateExtentValue(value.y, "2D bin y extent");
 }
@@ -152,9 +155,9 @@ function validateResolved(value, bins) {
   if (!isPlainObject(value.extent) || !isPlainObject(value.edges)) {
     throw new TypeError("Resolved 2D bin extent and edges must be objects.");
   }
-  rejectUnknownKeys(value.extent, EXTENT_KEYS, "resolved 2D bin extent");
-  rejectUnknownKeys(value.edges, EXTENT_KEYS, "resolved 2D bin edges");
-  for (const axis of ["x", "y"]) {
+  rejectUnknownKeys(value.extent, AXIS_KEYS, "resolved 2D bin extent");
+  rejectUnknownKeys(value.edges, AXIS_KEYS, "resolved 2D bin edges");
+  for (const axis of AXIS_KEYS) {
     validateExtentValue(
       value.extent[axis],
       `Resolved 2D bin ${axis} extent`,
@@ -223,8 +226,7 @@ export function normalizeBin2DTransform({
 }
 
 function resolveExtent(values, requested, axis) {
-  const minimum = Math.min(...values);
-  const maximum = Math.max(...values);
+  const [minimum, maximum] = numericExtent(values);
   const extent = requested === "auto" ? [minimum, maximum] : requested;
   if (extent[0] > minimum || extent[1] < maximum) {
     throw new RangeError(
@@ -237,12 +239,24 @@ function resolveExtent(values, requested, axis) {
   return [...extent];
 }
 
-function createEdges(extent, count) {
+function createEdges(extent, count, axis) {
   const [minimum, maximum] = extent;
   const step = (maximum - minimum) / count;
-  return Array.from({ length: count + 1 }, (_, index) =>
-    index === count ? maximum : minimum + step * index
+  const edges = Array.from({ length: count + 1 }, (_, index) =>
+    index === count
+      ? maximum
+      : Number.isFinite(step)
+        ? minimum + step * index
+        : interpolateNumber(minimum, maximum, index / count)
   );
+  if (edges.some((edge, index) =>
+    !Number.isFinite(edge) || index > 0 && edge <= edges[index - 1]
+  )) {
+    throw new RangeError(
+      `2D bin ${axis} extent cannot represent ${count} distinct bins.`
+    );
+  }
+  return edges;
 }
 
 function findBinIndex(value, edges) {
@@ -287,8 +301,8 @@ export function deriveBin2DRows(rows, transform) {
     )
   };
   const edges = {
-    x: createEdges(extent.x, transform.bins.x),
-    y: createEdges(extent.y, transform.bins.y)
+    x: createEdges(extent.x, transform.bins.x, "x"),
+    y: createEdges(extent.y, transform.bins.y, "y")
   };
   const buckets = Array.from(
     { length: transform.bins.x * transform.bins.y },

package/src/grammar/boxPlot.js

@@ -1,4 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { interpolateNumber, stableDecimal } from "./numeric.js";
 
 export const BOX_FIELDS = Object.freeze({
   q1: "__boxPlot_q1", median: "__boxPlot_median", q3: "__boxPlot_q3",
@@ -7,10 +8,10 @@ export const BOX_FIELDS = Object.freeze({
   count: "__boxPlot_count"
 });
 
-const TRANSFORM_KEYS = Object.freeze([
+const TRANSFORM_KEYS = [
   "type", "category", "field", "method", "whisker", "factor", "as"
-]);
-const OUTPUT_KEYS = Object.freeze(Object.keys(BOX_FIELDS));
+];
+const OUTPUT_KEYS = Object.keys(BOX_FIELDS);
 
 function field(value, label) {
   if (typeof value !== "string" || value.length === 0) throw new TypeError(`${label} must be a non-empty string.`);
@@ -82,11 +83,7 @@ function quantile(sorted, p) {
   const position = (sorted.length - 1) * p;
   const lower = Math.floor(position);
   const upper = Math.ceil(position);
-  return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
-}
-
-function stableNumber(value) {
-  return Number(value.toFixed(12));
+  return interpolateNumber(sorted[lower], sorted[upper], position - lower);
 }
 
 export function deriveBoxData(rows, transform) {
@@ -113,15 +110,19 @@ export function deriveBoxData(rows, transform) {
   const outlierSet = new Set();
   for (const group of groups) {
     const sorted = group.rows.map(row => row[measure]).sort((a, b) => a - b);
-    const q1 = stableNumber(quantile(sorted, 0.25));
-    const median = stableNumber(quantile(sorted, 0.5));
-    const q3 = stableNumber(quantile(sorted, 0.75));
+    const [q1, median, q3] = [0.25, 0.5, 0.75].map(probability =>
+      stableDecimal(quantile(sorted, probability))
+    );
+    const spread = q3 - q1;
     const lowerFence = whisker === "minmax"
       ? sorted[0]
-      : stableNumber(q1 - factor * (q3 - q1));
+      : stableDecimal(q1 - factor * spread);
     const upperFence = whisker === "minmax"
       ? sorted.at(-1)
-      : stableNumber(q3 + factor * (q3 - q1));
+      : stableDecimal(q3 + factor * spread);
+    if (![lowerFence, upperFence].every(Number.isFinite)) {
+      throw new RangeError("Box Tukey fences are outside the finite numeric range.");
+    }
     const inliers = sorted.filter(value => value >= lowerFence && value <= upperFence);
     const lowerWhisker = inliers[0];
     const upperWhisker = inliers.at(-1);