ggaction 0.0.18 → 0.0.19

package/src/grammar/facets/legendIntent.js

@@ -0,0 +1,65 @@
+import { isPlainObject } from "../../core/immutable.js";
+import { validateOptionObject, validateNonEmptyString } from "../../core/validation.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { LEGEND_CONFIG_KINDS, LEGEND_POSITIONS } from "../../core/vocabulary.js";
+import { describeLegendBlock } from "../legendBlocks.js";
+import { validateLegendGroupState } from "../legendGroups.js";
+import { resolveSharedFacetLegends, sameFacetGuideValue as same } from "./guides.js";
+
+const CONFIG_KEYS = Object.freeze([
+  "kind", "target", "channels", "scales", "scale", "field", "fieldType", "domain", "title", "titleVisible",
+  "inferredTitle", "inferredSymbol", "inferredStrokeWidth", "inferredOffset", "position", "align", "offset", "direction", "columns",
+  "titlePosition", "symbol", "labels", "titleStyle", "itemGap", "layout", "overflow", "border", "gradient",
+  "count", "sampling", "representation", "gradientDirection", "inheritAppearance", "inheritPosition", "blockOverrides",
+  "combine", "sizeAreas", "clipHeight"
+]);
+
+export function isAuthoredFacetLegend(value) {
+  return isPlainObject(value) && value.type === "authored-legend";
+}
+
+export function validateAuthoredFacetLegend(program, intent) {
+  validateOptionObject(intent, ["type", "blocks", "groups"], "Stored parent legend");
+  if (!isAuthoredFacetLegend(intent) || Object.keys(intent).length !== 3 ||
+      !isPlainObject(intent.blocks) || Object.keys(intent.blocks).length === 0 || !isPlainObject(intent.groups)) {
+    throw new Error("Stored parent legend requires its closed authored block intent.");
+  }
+  validateLegendGroupState(intent.groups);
+  const configs = {};
+  for (const [kind, block] of Object.entries(intent.blocks)) {
+    if (!LEGEND_CONFIG_KINDS.includes(kind)) throw new Error("Stored parent legend has an unknown block kind.");
+    validateOptionObject(block, ["config", "guide"], "Stored parent legend block");
+    validateOptionObject(block.config, kind === "colorSize" ? [...CONFIG_KEYS, "colorScale", "sizeScale"] : CONFIG_KEYS, "Stored parent legend config");
+    const config = block.config;
+    validateUserId(config.target, "Parent legend target");
+    if (!LEGEND_POSITIONS.includes(config.position)) throw new Error("Stored parent legend requires a native position.");
+    for (const flag of ["inferredTitle", "inferredSymbol", "inferredStrokeWidth", "inferredOffset", "titleVisible", "inheritAppearance", "inheritPosition"]) {
+      if (config[flag] !== undefined && typeof config[flag] !== "boolean") throw new Error(`Stored parent legend ${flag} must be boolean.`);
+    }
+    const descriptor = describeLegendBlock(program, kind, config);
+    if (block.guide !== undefined) {
+      validateOptionObject(block.guide, kind === "colorSize" ? ["colorScale", "sizeScale", "title"]
+        : ["scale", "scales", "channels", "title", "order"], "Stored parent legend meaning");
+      if (kind === "colorSize" && (block.guide.colorScale !== config.colorScale || block.guide.sizeScale !== config.sizeScale)) {
+        throw new Error("Stored parent color-size meaning must match both block scale bindings.");
+      }
+      if (block.guide.title !== undefined) validateNonEmptyString(block.guide.title, "Parent legend title");
+      if (block.guide.channels !== undefined && !same([...block.guide.channels].sort(), descriptor.channels)) {
+        throw new Error("Stored parent legend meaning must match its block channels.");
+      }
+      if (block.guide.scale !== undefined && block.guide.scale !== descriptor.scaleIds[0] ||
+          block.guide.scales !== undefined && !same(block.guide.scales, descriptor.scaleIds)) {
+        throw new Error("Stored parent legend meaning must match its block scale binding.");
+      }
+    }
+    if (!same(config, program.guideConfigs.legend?.[kind])) throw new Error("Parent legend materialization must match its authored owner.");
+    configs[kind] = config;
+  }
+  if (!same(Object.keys(configs).sort(), Object.keys(program.guideConfigs.legend ?? {}).sort()) ||
+      !same(intent.groups, program.guideConfigs.legendGroups ?? {})) {
+    throw new Error("Parent legend materialization must contain exactly its authored blocks and groups.");
+  }
+  resolveSharedFacetLegends(program.compositionSpec.children.map(id => ({ id,
+    guideConfigs: { legend: configs, legendGroups: intent.groups }, resolvedScales: program.children[id].resolvedScales })));
+  return intent;
+}

package/src/grammar/guideDash.js

@@ -0,0 +1 @@
+import{isPlainObject as i}from"../core/immutable.js";import{validateGeneratedItemLimit as o}from"../core/validation.js";function n(e,s="Guide strokeDash"){if(!Array.isArray(e)||e.length%2!==0||!e.every(r=>Number.isFinite(r)&&r>=0))throw new TypeError(`${s} must be an even-length array of non-negative finite numbers.`);return o(e.length,s),e}function u(e,{reset:s=!0}={}){if(e==="auto"&&s)return;if(!Array.isArray(e))throw new TypeError("Guide strokeDashMap must be an array.");o(e.length,"Guide strokeDashMap count");const r=new Set,a=e.map(t=>{if(!i(t)||Reflect.ownKeys(t).length!==2||!Object.hasOwn(t,"value")||!Object.hasOwn(t,"strokeDash"))throw new TypeError("Guide strokeDashMap entries must contain exactly value and strokeDash.");if(!["string","boolean"].includes(typeof t.value)&&!Number.isFinite(t.value))throw new TypeError("Guide strokeDashMap values must be strings, booleans, or finite numbers.");if(r.has(t.value))throw new Error("Guide strokeDashMap contains a duplicate typed value.");return r.add(t.value),n(t.strokeDash),Object.freeze({value:t.value,strokeDash:Object.freeze([...t.strokeDash])})});return a.length===0?void 0:Object.freeze(a)}function d(e,s){const r={...e};if(Object.hasOwn(s,"strokeDash")&&(n(s.strokeDash),r.strokeDash=[...s.strokeDash]),Object.hasOwn(s,"strokeDashMap")){const a=u(s.strokeDashMap);a===void 0?delete r.strokeDashMap:r.strokeDashMap=a}return r}function D(e,s){const r=new Map(s.strokeDashMap?.map(a=>[a.value,a.strokeDash]));return e.map(a=>r.get(a)??s.strokeDash??[])}export{u as normalizeGuideDashMap,d as patchGuideDash,D as resolveGuideDashes,n as validateGuideDash};

package/src/grammar/legendBlocks.js

@@ -0,0 +1 @@
+import{LEGEND_CHANNELS as d,LEGEND_CONFIG_KINDS as h}from"../core/vocabulary.js";import{isEnumeratedSizeScaleType as u}from"./scales/size.js";function y(e,r){if(!Array.isArray(e))throw new TypeError(`${r} channels must be an array.`);if(e.length===0)throw new Error(`${r} channels must select at least one channel.`);const s=new Set;for(const t of e){if(!d.includes(t))throw new Error(`Unsupported legend channel "${t}".`);if(s.has(t))throw new Error(`${r} channels contains duplicate "${t}".`);s.add(t)}}const o=Object.freeze(["series","color","stroke"]),a=Object.freeze({size:"size",opacity:"opacity",strokeWidth:"strokeWidth",gradient:"color",interval:"color",strokeGradient:"stroke",strokeInterval:"stroke"}),c=(e,r)=>e<r?-1:e>r?1:0;function w(e,r){const s=e==="colorSize"?["color","size"]:o.includes(e)?r?.channels:a[e]===void 0?void 0:[a[e]];if(!Array.isArray(s)||s.length===0)throw new Error(`Legend block ${e} requires at least one channel.`);return y(s,`Legend block ${e}`),Object.freeze([...s].sort(c))}function p(e){if(!Array.isArray(e)||e.length===0)throw new TypeError("Legend block key requires a non-empty channel array.");return JSON.stringify([...e].sort(c))}function b(e,r,s){if(!h.includes(r))throw new Error(`Unknown legend block kind "${r}".`);const t=w(r,s),n=r==="colorSize"?[s.colorScale,s.sizeScale]:o.includes(r)?s?.scales:[s?.scale];if(!Array.isArray(n)||n.length===0||n.some(l=>typeof l!="string"||e.resolvedScales[l]===void 0))throw new Error(`Legend block ${r} requires resolved scales.`);const i=o.includes(r)?"categorical":r==="colorSize"?"sampled":r==="size"?u(e.resolvedScales[n[0]].type)?"discrete-size":"sampled":["opacity","strokeWidth"].includes(r)||r==="gradient"&&s.representation==="symbols"?"sampled":["gradient","strokeGradient"].includes(r)?"gradient":"interval";return Object.freeze({target:s.target,kind:r,family:i,key:p(t),channels:t,scaleIds:Object.freeze([...n]),config:s})}function g(e,r){return e.symbol.layers.length===1&&(e.kind==="series"&&r==="line"||["color","stroke"].includes(e.kind)&&r==="swatch")?`${e.kind}LegendSymbols`:`${e.kind}LegendSymbol${{line:"Lines",point:"Points",swatch:"Swatches"}[r]}`}export{g as categoricalLegendSymbolId,b as describeLegendBlock,w as legendBlockChannels,p as legendBlockKey,y as validateLegendChannels};

package/src/grammar/legendBorder.js

@@ -0,0 +1,9 @@
+// Legend borders use one closed rectangular path, so odd dash duplication is not implicit.
+export function normalizeLegendBorderDash(value, label = "Legend border strokeDash") {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || value.length % 2 !== 0 ||
+      ![...value].every(item => Number.isFinite(item) && item >= 0)) {
+    throw new TypeError(`${label} must be an even-length array of non-negative finite numbers.`);
+  }
+  return Object.freeze([...value]);
+}

package/src/grammar/legendClip.js

@@ -0,0 +1,19 @@
+export function normalizeLegendClipHeight(value,{edit=false}={}){
+ if(value===undefined||edit&&value==='auto')return undefined;
+ if(!Number.isFinite(value)||value<=0)throw new RangeError('Legend clipHeight must be a positive finite number.');
+ return value;
+}
+export function validateLegendClip(kind,config){
+ if(config.clipHeight===undefined)return;
+ normalizeLegendClipHeight(config.clipHeight);
+ const supported=['size','opacity','colorSize'].includes(kind)||kind==='gradient'&&config.representation==='symbols'||
+  ['series','color','stroke'].includes(kind)&&config.symbol?.layers?.some(layer=>layer.type==='point');
+ if(!supported)throw new Error('Legend clipHeight requires a point-bearing sample block.');
+}
+export function patchLegendClipHeight(config,value){
+ const {clipHeight:_old,...rest}=config,clipHeight=normalizeLegendClipHeight(value,{edit:true});
+ return clipHeight===undefined?rest:{...rest,clipHeight};
+}
+export function clippedSampleBounds(bounds,height){
+ return height===undefined?bounds:{...bounds,top:Math.max(bounds.top,-height/2),bottom:Math.min(bounds.bottom,height/2)};
+}

package/src/grammar/legendCombinations.js

@@ -0,0 +1,45 @@
+import { sameOrderedValues, validateGeneratedItemLimit } from "../core/validation.js";
+import { mapOrdinalValues } from "./scales/index.js";
+import { readNominalField } from "./scales/fields.js";
+import { resolveLegendOrderDomain } from "./categoryOrder.js";
+
+export function isSizeShapeChannels(channels) {
+  return Array.isArray(channels) && channels.length === 2 &&
+    channels.includes('shape') && channels.includes('size');
+}
+export function validateLegendCombine(value) {
+  if(value===undefined)return;
+  if (!['separate','size-shape','color-size'].includes(value)) throw new Error('Legend combine must be separate, size-shape, or color-size.');
+}
+export function validateMappedSizeShapeSymbol(symbol) {
+  if(symbol===undefined||symbol==='auto')return;
+  const layers=symbol.layers??[];
+  if(layers.some(layer=>layer.type==='point'&&(Object.hasOwn(layer,'shape')||Object.hasOwn(layer,'size')))) {
+    throw new Error('Combined size-shape symbols cannot override mapped shape or size.');
+  }
+}
+
+export function resolveSizeShapeMapping({layer,scales,order,rows}) {
+  const shape=layer?.encoding?.shape,size=layer?.encoding?.size;
+  const shapeScale=scales[shape?.scale],sizeScale=scales[size?.scale];
+  if(layer?.mark?.type!=="point"||shape?.field!==size?.field||
+      !["nominal","ordinal"].includes(size?.fieldType)||shapeScale?.type!=="ordinal"||
+      sizeScale?.type!=="ordinal"||!sameOrderedValues(shapeScale.domain,sizeScale.domain)) {
+    throw new Error("Combined size-shape requires one categorical point field and identical ordered domains.");
+  }
+  validateGeneratedItemLimit(shapeScale.domain.length,"Categorical legend item count");
+  if(shapeScale.domain.length===0||sizeScale.range.some(area=>!Number.isFinite(area)||area<0)) {
+    throw new Error("Combined size-shape requires a nonempty domain and finite nonnegative areas.");
+  }
+  let linked;
+  if(order?.channel!==undefined){
+    const position=layer.encoding[order.channel];
+    if(!["nominal","ordinal"].includes(position?.fieldType)||position.field!==shape.field) {
+      throw new Error("Linked legend order requires the same categorical field on its target.");
+    }
+    linked=scales[position.scale]?.domain;
+  }
+  const domain=resolveLegendOrderDomain(shapeScale.domain,order,linked,
+    order?.values===undefined?undefined:readNominalField(rows,shape.field));
+  return {domain,sizeAreas:mapOrdinalValues(domain,sizeScale.domain,sizeScale.range)};
+}

package/src/grammar/legendGradient.js

@@ -16,3 +16,12 @@ export function normalizeLegendGradient(patch, previous = DEFAULT_LEGEND_GRADIEN
   validateLegendGradient(value);
   return value;
 }
+
+
+export function normalizeGradientDirection(value, label = "Gradient legend direction") {
+  if (value === undefined) return undefined;
+  if (value !== "horizontal" && value !== "vertical") {
+    throw new Error(`${label} must be horizontal or vertical.`);
+  }
+  return value;
+}

package/src/grammar/legendGroups.js

@@ -1 +1 @@
-import{validateOptionObject as r,validateNonNegativeFinite as i}from"../core/validation.js";import{validateUserId as a}from"../core/identifiers.js";import{PLOT_LEGEND_POSITIONS as g,LEGEND_POSITIONS as d,LEGEND_BLOCK_LAYOUTS as f}from"../core/vocabulary.js";function s(n){r(n,void 0,"Legend groups");for(const[o,t]of Object.entries(n)){if(a(o,"Legend group target"),r(t,["placement","blockLayout","inferredOffset"],"Legend group"),!f.includes(t.blockLayout))throw new Error("Legend group blockLayout must be row, column or wrap.");if(t.inferredOffset!==void 0&&typeof t.inferredOffset!="boolean")throw new TypeError("Legend group inferredOffset must be boolean.");const e=t.placement;if(r(e,["at","position","align","offset"],"Legend group placement"),Object.hasOwn(e,"at")){if(Object.keys(e).length!==1)throw new Error("Legend group at cannot coexist with an edge anchor.");if(r(e.at,["x","y"],"Legend group at"),!Number.isFinite(e.at.x)||!Number.isFinite(e.at.y))throw new Error("Legend group at requires finite x and y.")}else{if(Object.keys(e).length!==3||!d.includes(e.position))throw new Error("Legend group requires a complete edge placement.");if(!["left","center","right"].includes(e.align))throw new Error("Unsupported legend group alignment.");if((g.includes(e.position)||["left","right"].includes(e.position))&&e.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");i(e.offset,"Legend group offset")}}return n}export{s as validateLegendGroupState};
+import{validateOptionObject as o,validateNonNegativeFinite as d}from"../core/validation.js";import{validateUserId as l}from"../core/identifiers.js";import{PLOT_LEGEND_POSITIONS as i,LEGEND_POSITIONS as a,LEGEND_BLOCK_LAYOUTS as f}from"../core/vocabulary.js";function c(n){o(n,void 0,"Legend groups");for(const[t,r]of Object.entries(n)){if(l(t,"Legend group target"),o(r,["placement","blockLayout","inferredOffset"],"Legend group"),!f.includes(r.blockLayout))throw new Error("Legend group blockLayout must be row, column or wrap.");if(r.inferredOffset!==void 0&&typeof r.inferredOffset!="boolean")throw new TypeError("Legend group inferredOffset must be boolean.");const e=r.placement;if(o(e,["at","position","align","offset"],"Legend group placement"),Object.hasOwn(e,"at")){if(Object.keys(e).length!==1)throw new Error("Legend group at cannot coexist with an edge anchor.");if(o(e.at,["x","y"],"Legend group at"),!Number.isFinite(e.at.x)||!Number.isFinite(e.at.y))throw new Error("Legend group at requires finite x and y.")}else{if(Object.keys(e).length!==3||!a.includes(e.position))throw new Error("Legend group requires a complete edge placement.");if(!["left","center","right"].includes(e.align))throw new Error("Unsupported legend group alignment.");if((i.includes(e.position)||["left","right"].includes(e.position))&&e.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");d(e.offset,"Legend group offset")}}return n}function s(n){const t=Object.values(n?.blockOverrides??{}).map(r=>r.position).filter(r=>r!==void 0);if(t.length>1)throw new Error("Legend family has ambiguous local positions.");if(t.length&&!a.includes(t[0]))throw new Error("Invalid local legend position.");return t[0]}function m(n){const t=s(n);if(t!==void 0)return{position:t,align:["top","bottom"].includes(t)?n.align??"center":"center",offset:i.includes(t)?8:n.offset??(n.channels===void 0?30:8),inferredOffset:n.inferredOffset??!0}}export{m as localLegendPlacement,s as localLegendPosition,c as validateLegendGroupState};

package/src/grammar/legendOpacity.js

@@ -0,0 +1,6 @@
+export function validateLegendLayerOpacity(value) {
+  if(value!==undefined&&(!Number.isFinite(value)||value<0||value>1)) {
+    throw new RangeError("Legend symbol layer opacity must be finite and between 0 and 1.");
+  }
+  return value;
+}

package/src/grammar/pointShapes.js

@@ -14,7 +14,9 @@ export const POINT_SHAPES = cloneAndFreeze([
   "cross",
   "star",
   "hexagon",
-  "wye"
+  "wye",
+  "wedge",
+  "arrow"
 ]);
 
 const SHAPE_SET = new Set(POINT_SHAPES);
@@ -98,7 +100,19 @@ function shapePolygon(shape) {
     cross: rotate(plus, Math.PI / 4),
     star: alternatingPolygon(5, 0.45),
     hexagon: regularPolygon(6),
-    wye: alternatingPolygon(3, 0.28)
+    wye: alternatingPolygon(3, 0.28),
+    wedge: [
+      { x: 0, y: -2 / Math.sqrt(3) },
+      { x: -1 / 4, y: 1 / Math.sqrt(3) },
+      { x: 1 / 4, y: 1 / Math.sqrt(3) }
+    ],
+    // The directional arrow is anchored at its bounding-box center, not its centroid.
+    arrow: [
+      { x: -1 / 7, y: 1 }, { x: 1 / 7, y: 1 },
+      { x: 1 / 7, y: -1 / 8 }, { x: 2 / 5, y: -1 / 8 },
+      { x: 0, y: -1 }, { x: -2 / 5, y: -1 / 8 },
+      { x: -1 / 7, y: -1 / 8 }
+    ]
   }[shape];
 }
 

package/src/grammar/regression/derive.js

@@ -3,7 +3,7 @@ import {
   readNominalField,
   readQuantitativeField
 } from "../scales/index.js";
-import { fitRegressionGroup, predictRegressionAt } from "./models.js";
+import { fitRegressionGroup, predictRegressionAt, linearRegressionStatistics } from "./models.js";
 import { requireFiniteResult } from "../numeric.js";
 import {
   validateGeneratedItemLimit,
@@ -81,6 +81,7 @@ export function deriveRegression(values, {
   }
   const groups = [...groupedRows.keys()];
   const models = [];
+  const statistics = [];
   const rows = [];
   let work = 0;
 
@@ -119,6 +120,10 @@ export function deriveRegression(values, {
       parameters
     });
     models.push({ ...(groupBy === undefined ? {} : { group }), ...model, xValues });
+    if (parameters.method === "linear") statistics.push({
+      ...(groupBy === undefined ? {} : { group }),
+      ...linearRegressionStatistics(groupRows, model, { x, y })
+    });
 
     for (const xValue of xValues) {
       const prediction = predictRegressionAt(model, xValue, parameters);
@@ -163,6 +168,9 @@ export function deriveRegression(values, {
     parameters,
     groups,
     models,
+    ...(parameters.method === "linear" ? {
+      fitStatistics: { version: 1, method: "linear", groups: statistics }
+    } : {}),
     values: rows,
     ...(missing === undefined ? {} : {
       report: {

package/src/grammar/regression/models.js

@@ -477,7 +477,62 @@ function predictLoessAt(model, xValue) {
   }, "LOESS regression prediction").prediction;
 }
 
+function fitExponentialGroup(rows, { x, y, group }) {
+  const label = `Regression group "${group === undefined ? "all" : String(group)}"`;
+  if (rows.length < 2) throw new Error(`${label} requires at least two rows.`);
+  if (rows.some(row => !(row[y] > 0))) {
+    throw new RangeError("Exponential regression y values must be strictly positive.");
+  }
+  const xValues = rows.map(row => row[x]);
+  if (new Set(xValues).size < 2) throw new Error(`${label} requires varying x values.`);
+  const responseScale = maximumMagnitude(rows.map(row => row[y]));
+  const xMagnitude = maximumMagnitude(xValues) || 1;
+  const weights = rows.map(row => row[y] / responseScale);
+  const weightSum = weights.reduce((sum, value) => sum + value, 0);
+  const logs = rows.map(row => Math.log(row[y]));
+  const meanX = restoreFiniteScale(rows.reduce((sum, row, index) =>
+    sum + weights[index] * (row[x] / xMagnitude), 0) / weightSum,
+  xMagnitude, `${label} weighted x mean`);
+  const meanLogY = logs.reduce((sum, value, index) => sum + weights[index] * value, 0) / weightSum;
+  const [centeredX, xScale] = normalizedCoordinates(xValues, meanX);
+  const variance = centeredX.reduce((sum, value, index) => sum + weights[index] * value ** 2, 0);
+  if (variance === 0) throw new Error(`${label} requires varying x values.`);
+  const covariance = centeredX.reduce((sum, value, index) =>
+    sum + weights[index] * value * (logs[index] - meanLogY), 0);
+  const rate = restoreFiniteRatio(covariance / variance, 1, xScale, `${label} exponential rate`);
+  const logAmplitude = requireFiniteResult(meanLogY - rate * meanX, `${label} exponential log amplitude`);
+  const amplitude = requireFiniteResult(Math.exp(logAmplitude), `${label} exponential amplitude`);
+  if (amplitude === 0) throw new RangeError("Exponential regression amplitude must be positive and representable.");
+  return { count: rows.length, amplitude, rate, logAmplitude };
+}
+
+export function linearRegressionStatistics(rows, model, { x, y }) {
+  const responseScale = maximumMagnitude(rows.map(row => row[y])) || 1;
+  const [coordinates, xScale] = normalizedCoordinates(rows.map(row => row[x]), model.meanX);
+  const normalizedSlope = model.normalizedResponseSlope ?? (
+    Number.isFinite(model.slope * xScale) && (model.slope * xScale !== 0 || model.slope === 0)
+      ? model.slope * xScale / responseScale
+      : restoreFiniteRatio(model.slope, xScale, responseScale, "Linear regression normalized slope")
+  );
+  let residualSquares = 0;
+  let totalSquares = 0;
+  rows.forEach((row, index) => {
+    const difference = row[y] - model.meanY;
+    const centered = Number.isFinite(difference)
+      ? difference / responseScale
+      : row[y] / responseScale - model.meanY / responseScale;
+    const residual = centered - normalizedSlope * coordinates[index];
+    totalSquares += centered ** 2;
+    residualSquares += residual ** 2;
+  });
+  return {
+    count: rows.length, intercept: model.intercept, slope: model.slope,
+    rSquared: totalSquares === 0 ? null : 1 - residualSquares / totalSquares
+  };
+}
+
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
+  if (parameters.method === "exp") return fitExponentialGroup(rows, { x, y, group });
   if (parameters.method === "linear") {
     return fitLinearGroup(rows, {
       x,
@@ -509,9 +564,14 @@ export function predictRegressionAt(model, xValue, parameters) {
     : undefined;
   const prediction = parameters.method === "linear"
     ? linearPrediction(model, xValue)
+    : parameters.method === "exp"
+      ? requireFiniteResult(Math.exp(model.logAmplitude + model.rate * xValue), "Exponential regression prediction")
     : parameters.method === "polynomial"
       ? polynomial.prediction
       : predictLoessAt(model, xValue);
+  if (parameters.method === "exp" && prediction === 0) {
+    throw new RangeError("Exponential regression prediction must be positive and representable.");
+  }
   if (parameters.method === "loess" || parameters.interval === false) return { prediction };
   const leverage = parameters.method === "linear"
     ? model.normalizedSxx !== undefined

package/src/grammar/regression/parameters.js

@@ -51,9 +51,17 @@ export function normalizeRegressionParameters({
   confidence,
   interval
 } = {}) {
-  if (!["linear", "polynomial", "loess"].includes(method)) {
+  if (!["linear", "polynomial", "loess", "exp"].includes(method)) {
     throw new Error(`Unsupported regression method "${method}".`);
   }
+  if (method === "exp") {
+    if (degree !== undefined || span !== undefined || robustIterations !== undefined ||
+        confidenceMethod !== undefined || level !== undefined || confidence !== undefined ||
+        (interval !== undefined && interval !== false)) {
+      throw new Error("Exponential regression only supports interval false and no confidence or method-specific options.");
+    }
+    return cloneAndFreeze({ method, interval: false });
+  }
   if (method === "loess") {
     if (degree !== undefined) {
       throw new Error("Regression degree requires the polynomial method.");

package/src/grammar/regression/statistics.js

@@ -0,0 +1,64 @@
+import { isPlainObject } from "../../core/immutable.js";
+import { rejectUnknownProperties } from "../../core/validation.js";
+
+export const REGRESSION_STATISTIC_FIELDS = Object.freeze(["count", "intercept", "slope", "rSquared"]);
+
+export function validateRegressionStatisticsTransform(transform) {
+  if (!isPlainObject(transform)) throw new TypeError("Regression statistics transform must be a plain object.");
+  rejectUnknownProperties(transform, ["type"], "regression statistics transform");
+  if (transform.type !== "regressionStatistics") throw new Error("Unsupported regression statistics transform.");
+  return transform;
+}
+
+export function requireRegressionStatisticsSource(source) {
+  const transform = source?.transform?.[0];
+  if (source?.transform?.length !== 1 || transform.type !== "regression") {
+    throw new Error("Regression statistics source must be a regression dataset.");
+  }
+  if (transform.method !== "linear") throw new Error("Regression statistics only supports linear regression.");
+  if (REGRESSION_STATISTIC_FIELDS.includes(transform.groupBy)) {
+    throw new Error(`Regression statistics group field "${transform.groupBy}" collides with a statistic output.`);
+  }
+  return transform;
+}
+
+export function validateRegressionFitStatistics(cache, dataset, source) {
+  if (!isPlainObject(cache)) throw new TypeError("Regression fit statistics must be a plain object.");
+  rejectUnknownProperties(cache, ["version", "method", "groups"], "regression fit statistics");
+  const transform = dataset?.transform?.[0];
+  if (dataset?.transform?.length !== 1 || transform.type !== "regression" || transform.method !== "linear" ||
+      !Array.isArray(dataset.values) || cache.version !== 1 || cache.method !== "linear" || !Array.isArray(cache.groups)) {
+    throw new Error("Regression fit statistics requires a materialized linear owner and version 1 groups.");
+  }
+  const expected = new Map();
+  for (const row of source?.values ?? []) {
+    if (transform.missing === "drop" && (row[transform.x] == null || row[transform.y] == null)) continue;
+    if (!Number.isFinite(row[transform.x]) || !Number.isFinite(row[transform.y])) {
+      throw new Error("Regression fit statistics source must contain eligible finite pairs.");
+    }
+    const key = transform.groupBy === undefined ? undefined : row[transform.groupBy];
+    expected.set(key, (expected.get(key) ?? 0) + 1);
+  }
+  const groups = [...expected.entries()];
+  if (groups.length !== cache.groups.length) throw new Error("Regression fit statistics group count does not match its source.");
+  cache.groups.forEach((row, index) => {
+    if (!isPlainObject(row)) throw new TypeError("Regression fit statistic row must be a plain object.");
+    const grouped = transform.groupBy !== undefined;
+    rejectUnknownProperties(row, [...REGRESSION_STATISTIC_FIELDS, ...(grouped ? ["group"] : [])], "regression fit statistic row");
+    if (grouped && !Object.is(row.group, groups[index][0]) ||
+        !Number.isSafeInteger(row.count) || row.count < 2 || row.count !== groups[index][1] ||
+        !Number.isFinite(row.intercept) || !Number.isFinite(row.slope) ||
+        row.rSquared !== null && !Number.isFinite(row.rSquared)) {
+      throw new Error("Regression fit statistics contains invalid coefficients, group identity or observation count.");
+    }
+  });
+  return cache;
+}
+
+export function regressionStatisticsRows(cache, dataset) {
+  const transform = requireRegressionStatisticsSource(dataset);
+  return cache.groups.map(({ group, count, intercept, slope, rSquared }) => ({
+    ...(transform.groupBy === undefined ? {} : { [transform.groupBy]: group }),
+    count, intercept, slope, rSquared
+  }));
+}

package/src/grammar/scales/color.js

@@ -1 +1 @@
-import{mapTransformedValues as $}from"./transformed.js";import{cloneAndFreeze as p,isPlainObject as k}from"../../core/immutable.js";import{validateGeneratedItemLimit as F}from"../../core/validation.js";import{normalizePalette as P,resolveContinuousPalette as T}from"../palettes.js";import{inverseLerp as w}from"../numeric.js";const B=p(["rgb","hsl","hsl-long","lab","hcl","hcl-long","cubehelix","cubehelix-long"]),D=Object.freeze({black:"#000000",blue:"#0000ff",cyan:"#00ffff",gray:"#808080",green:"#008000",grey:"#808080",magenta:"#ff00ff",navy:"#000080",orange:"#ffa500",purple:"#800080",red:"#ff0000",teal:"#008080",white:"#ffffff",yellow:"#ffff00"});function M(t,r=0,n=1){return Math.max(r,Math.min(n,t))}function m(t){return(t%360+360)%360}function x({h:t,s:r,l:n}){const e=(1-Math.abs(2*n-1))*r,s=m(t)/60,i=e*(1-Math.abs(s%2-1)),[o,c,l]=s<1?[e,i,0]:s<2?[i,e,0]:s<3?[0,e,i]:s<4?[0,i,e]:s<5?[i,0,e]:[e,0,i],a=n-e/2;return{r:o+a,g:c+a,b:l+a}}function y(t){if(typeof t!="string"||t.length===0)throw new TypeError("Continuous color range requires non-empty color strings.");const r=D[t.toLowerCase()]??t.toLowerCase();let n=r.match(/^#([0-9a-f]{3})$/i);if(n)return Object.fromEntries(["r","g","b"].map((e,s)=>[e,Number.parseInt(n[1][s].repeat(2),16)/255]));if(n=r.match(/^#([0-9a-f]{6})$/i),n)return{r:Number.parseInt(n[1].slice(0,2),16)/255,g:Number.parseInt(n[1].slice(2,4),16)/255,b:Number.parseInt(n[1].slice(4,6),16)/255};if(n=r.match(/^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/),n){const s=r.includes("%")?100:255,i=n.slice(1).map(o=>Number(o)/s);if(i.every(o=>Number.isFinite(o)&&o>=0&&o<=1))return{r:i[0],g:i[1],b:i[2]}}if(n=r.match(/^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/),n){const e=Number(n[1]),s=Number(n[2])/100,i=Number(n[3])/100;if([e,s,i].every(Number.isFinite)&&s>=0&&s<=1&&i>=0&&i<=1)return x({h:e,s,l:i})}throw new Error(`Unsupported continuous color "${t}".`)}function q({r:t,g:r,b:n}){return`#${[t,r,n].map(e=>Math.round(M(e)*255).toString(16).padStart(2,"0")).join("")}`}function N({r:t,g:r,b:n}){return[t,r,n].map(e=>Math.round(e*255))}function A({r:t,g:r,b:n}){const e=Math.max(t,r,n),s=Math.min(t,r,n),i=e-s,o=(e+s)/2;if(i===0)return{h:0,s:0,l:o};const c=i/(1-Math.abs(2*o-1)),l=e===t?(r-n)/i%6:e===r?(n-t)/i+2:(t-r)/i+4;return{h:m(l*60),s:c,l:o}}function C(t){return t<=.04045?t/12.92:((t+.055)/1.055)**2.4}function E(t){return t<=.0031308?12.92*t:1.055*t**(1/2.4)-.055}function d(t){const r=C(t.r),n=C(t.g),e=C(t.b),s=(.4124564*r+.3575761*n+.1804375*e)/.95047,i=.2126729*r+.7151522*n+.072175*e,o=(.0193339*r+.119192*n+.9503041*e)/1.08883,c=u=>u>216/24389?Math.cbrt(u):841/108*u+4/29,l=c(s),a=c(i),f=c(o);return{l:116*a-16,a:500*(l-a),b:200*(a-f)}}function O({l:t,a:r,b:n}){const e=(t+16)/116,s=e+r/500,i=e-n/200,o=f=>f**3>216/24389?f**3:108/841*(f-4/29),c=.95047*o(s),l=o(e),a=1.08883*o(i);return{r:E(3.2404542*c-1.5371385*l-.4985314*a),g:E(-.969266*c+1.8760108*l+.041556*a),b:E(.0556434*c-.2040259*l+1.0572252*a)}}function I({l:t,a:r,b:n}){return{h:m(Math.atan2(n,r)*180/Math.PI),c:Math.hypot(r,n),l:t}}function U({h:t,c:r,l:n}){const e=t*Math.PI/180;return{l:n,a:Math.cos(e)*r,b:Math.sin(e)*r}}function R({r:t,g:r,b:n}){const l=-1.7884503806,a=1.97294*1.78277,f=1.78277*-.29227- -.90649*-.14861,u=(f*n+l*t-a*r)/(f+l-a),b=n-u,h=(1.97294*(r-u)- -.29227*b)/-.90649,g=1.97294*u*(1-u);return{h:m(Math.atan2(h,b)*180/Math.PI-120),s:g===0?0:Math.hypot(h,b)/g,l:u}}function W({h:t,s:r,l:n}){const e=(t+120)*Math.PI/180,s=r*n*(1-n),i=Math.cos(e),o=Math.sin(e);return{r:n+s*(-.14861*i+1.78277*o),g:n+s*(-.29227*i-.90649*o),b:n+s*(1.97294*i)}}function S(t,r,n,e){let s=r-t;return e||(s=(s+540)%360-180),m(t+s*n)}function H(t,r,n,e){if(e.startsWith("hsl")){const o=A(t),c=A(r);return x({h:S(o.h,c.h,n,e.endsWith("-long")),s:o.s+(c.s-o.s)*n,l:o.l+(c.l-o.l)*n})}if(e==="lab"){const o=d(t),c=d(r);return O({l:o.l+(c.l-o.l)*n,a:o.a+(c.a-o.a)*n,b:o.b+(c.b-o.b)*n})}if(e.startsWith("hcl")){const o=I(d(t)),c=I(d(r));return O(U({h:S(o.h,c.h,n,e.endsWith("-long")),c:o.c+(c.c-o.c)*n,l:o.l+(c.l-o.l)*n}))}const s=R(t),i=R(r);return W({h:S(s.h,i.h,n,e.endsWith("-long")),s:s.s+(i.s-s.s)*n,l:s.l+(i.l-s.l)*n})}function j(t){if(!B.includes(t))throw new Error(`Unsupported continuous color interpolation "${t}".`);return t}function _(t){if(t==="auto")return t;if(Array.isArray(t)){if(F(t.length,"Sequential color range length"),t.length<2)throw new TypeError("Sequential color range requires at least two colors.");return t.forEach(y),p(t)}if(!k(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new TypeError("Sequential color range requires colors or a palette descriptor.");const r=P(t.palette);if(r.count!==void 0&&r.count<2)throw new RangeError("Sequential palette count must be an integer of at least 2.");return p({palette:r})}function Y(t){const r=_(t);return r==="auto"?T("viridis"):Array.isArray(r)?p(r.map(n=>q(y(n)))):T(r.palette)}function z(t,r,n,e){const i=(e?M(r):r)*(t.length-1),o=Math.max(0,Math.min(t.length-2,Math.floor(i))),c=o+1,l=i-o;if(n==="rgb"){const a=N(t[o]),f=N(t[c]);return`#${a.map((u,b)=>Math.round(M(u+(f[b]-u)*l,0,255)).toString(16).padStart(2,"0")).join("")}`}return q(H(t[o],t[c],l,n))}function Z(t,r,n="rgb"){const e=j(n);if(!Array.isArray(t)||t.length<2)throw new TypeError("Color interpolation requires at least two stops.");const s=t.map(y);return z(s,r,e,!0)}function L(t,r,n="auto"){if(!(t===void 0||t==="auto")){if(r!=="sequential")throw new Error(`Scale type "${r}" does not support midpoint.`);if(!Number.isFinite(t))throw new TypeError("Scale midpoint must be finite or auto.");if(n!=="auto"&&(!Array.isArray(n)||n.length!==2||!n.every(Number.isFinite)||!(t>Math.min(...n)&&t<Math.max(...n))))throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");return t}}function G(t,r,n,e={}){const{interpolation:s="rgb",clamp:i=!1}=e;if(["log","sqrt","symlog"].includes(e.type)){L(e.midpoint,e.type,r);const h=$(t,r,[0,1],{type:e.type,clamp:i,...e.type==="log"?{base:e.base}:{},...e.type==="symlog"?{constant:e.constant}:{},...Object.hasOwn(e,"unknown")?{unknown:NaN}:{}});return G(h,[0,1],n,{...e,type:"sequential"})}const o=Object.hasOwn(e,"unknown");if(!Array.isArray(r)||r.length!==2||!r.every(Number.isFinite))throw new TypeError("Sequential color domain must contain two finite numbers.");if(!Array.isArray(t)||!o&&!t.every(Number.isFinite))throw new TypeError("Sequential color values must be finite numbers.");if(typeof i!="boolean")throw new TypeError("Sequential color clamp must be a boolean.");const c=L(e.midpoint,"sequential",r),[l,a]=r,f=l===a,u=j(s);if(!Array.isArray(n)||n.length<2)throw new TypeError("Color interpolation requires at least two stops.");const b=n.map(y);return p(t.map(h=>{if(!Number.isFinite(h)){if(o)return e.unknown;throw new TypeError("Sequential color values must be finite numbers.")}const g=c===void 0?f?.5:w(h,l,a):(a>l?h<=c:h>=c)?w(h,l,c)/2:.5+w(h,c,a)/2;return z(b,g,u,i)}))}export{B as CONTINUOUS_COLOR_INTERPOLATIONS,Z as interpolateColorStops,G as mapSequentialColors,Y as resolveSequentialColorStops,j as validateContinuousColorInterpolation,_ as validateSequentialColorRange,L as validateSequentialMidpoint};
+import{mapTransformedValues as F}from"./transformed.js";import{cloneAndFreeze as p,isPlainObject as j}from"../../core/immutable.js";import{validateGeneratedItemLimit as $}from"../../core/validation.js";import{normalizePalette as k,resolveContinuousPalette as S}from"../palettes.js";import{inverseLerp as C}from"../numeric.js";const B=p(["rgb","hsl","hsl-long","lab","hcl","hcl-long","cubehelix","cubehelix-long"]),D=Object.freeze({black:"#000000",blue:"#0000ff",cyan:"#00ffff",gray:"#808080",green:"#008000",grey:"#808080",magenta:"#ff00ff",navy:"#000080",orange:"#ffa500",purple:"#800080",red:"#ff0000",teal:"#008080",white:"#ffffff",yellow:"#ffff00"});function E(t,e=0,n=1){return Math.max(e,Math.min(n,t))}function d(t){return(t%360+360)%360}function q({h:t,s:e,l:n}){const r=(1-Math.abs(2*n-1))*e,o=d(t)/60,i=r*(1-Math.abs(o%2-1)),[a,u,l]=o<1?[r,i,0]:o<2?[i,r,0]:o<3?[0,r,i]:o<4?[0,i,r]:o<5?[i,0,r]:[r,0,i],s=n-r/2;return{r:a+s,g:u+s,b:l+s}}function w(t){if(typeof t!="string"||t.length===0)throw new TypeError("Continuous color range requires non-empty color strings.");const e=D[t.toLowerCase()]??t.toLowerCase();let n=e.match(/^#([0-9a-f]{3})$/i);if(n)return Object.fromEntries(["r","g","b"].map((r,o)=>[r,Number.parseInt(n[1][o].repeat(2),16)/255]));if(n=e.match(/^#([0-9a-f]{6})$/i),n)return{r:Number.parseInt(n[1].slice(0,2),16)/255,g:Number.parseInt(n[1].slice(2,4),16)/255,b:Number.parseInt(n[1].slice(4,6),16)/255};if(n=e.match(/^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/),n){const o=e.includes("%")?100:255,i=n.slice(1).map(a=>Number(a)/o);if(i.every(a=>Number.isFinite(a)&&a>=0&&a<=1))return{r:i[0],g:i[1],b:i[2]}}if(n=e.match(/^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/),n){const r=Number(n[1]),o=Number(n[2])/100,i=Number(n[3])/100;if([r,o,i].every(Number.isFinite)&&o>=0&&o<=1&&i>=0&&i<=1)return q({h:r,s:o,l:i})}throw new Error(`Unsupported continuous color "${t}".`)}function N({r:t,g:e,b:n}){return`#${[t,e,n].map(r=>Math.round(E(r)*255).toString(16).padStart(2,"0")).join("")}`}function T({r:t,g:e,b:n}){return[t,e,n].map(r=>Math.round(r*255))}function A({r:t,g:e,b:n}){const r=Math.max(t,e,n),o=Math.min(t,e,n),i=r-o,a=(r+o)/2;if(i===0)return{h:0,s:0,l:a};const u=i/(1-Math.abs(2*a-1)),l=r===t?(e-n)/i%6:r===e?(n-t)/i+2:(t-e)/i+4;return{h:d(l*60),s:u,l:a}}function x(t){return t<=.04045?t/12.92:((t+.055)/1.055)**2.4}function m(t){return t<=.0031308?12.92*t:1.055*t**(1/2.4)-.055}function y(t,e="d65"){const n=x(t.r),r=x(t.g),o=x(t.b),i=e==="d50"?(.4360747*n+.3850649*r+.1430804*o)/.96422:(.4124564*n+.3575761*r+.1804375*o)/.95047,a=e==="d50"?.2225045*n+.7168786*r+.0606169*o:.2126729*n+.7151522*r+.072175*o,u=e==="d50"?(.0139322*n+.0971045*r+.7141733*o)/.82521:(.0193339*n+.119192*r+.9503041*o)/1.08883,l=b=>b>216/24389?Math.cbrt(b):841/108*b+4/29,s=l(i),c=l(a),f=l(u);return{l:116*c-16,a:500*(s-c),b:200*(c-f)}}function O({l:t,a:e,b:n},r="d65"){const o=(t+16)/116,i=o+e/500,a=o-n/200,u=f=>f**3>216/24389?f**3:108/841*(f-4/29),l=(r==="d50"?.96422:.95047)*u(i),s=u(o),c=(r==="d50"?.82521:1.08883)*u(a);return r==="d50"?{r:m(3.1338561*l-1.6168667*s-.4906146*c),g:m(-.9787684*l+1.9161415*s+.033454*c),b:m(.0719453*l-.2289914*s+1.4052427*c)}:{r:m(3.2404542*l-1.5371385*s-.4985314*c),g:m(-.969266*l+1.8760108*s+.041556*c),b:m(.0556434*l-.2040259*s+1.0572252*c)}}function I({l:t,a:e,b:n}){return{h:d(Math.atan2(n,e)*180/Math.PI),c:Math.hypot(e,n),l:t}}function H({h:t,c:e,l:n}){const r=t*Math.PI/180;return{l:n,a:Math.cos(r)*e,b:Math.sin(r)*e}}function R({r:t,g:e,b:n}){const l=-1.7884503806,s=1.97294*1.78277,c=1.78277*-.29227- -.90649*-.14861,f=(c*n+l*t-s*e)/(c+l-s),b=n-f,h=(1.97294*(e-f)- -.29227*b)/-.90649,g=1.97294*f*(1-f);return{h:d(Math.atan2(h,b)*180/Math.PI-120),s:g===0?0:Math.hypot(h,b)/g,l:f}}function U({h:t,s:e,l:n}){const r=(t+120)*Math.PI/180,o=e*n*(1-n),i=Math.cos(r),a=Math.sin(r);return{r:n+o*(-.14861*i+1.78277*a),g:n+o*(-.29227*i-.90649*a),b:n+o*(1.97294*i)}}function M(t,e,n,r){let o=e-t;return r||(o=(o+540)%360-180),d(t+o*n)}function W(t,e,n,r,o){const i=o.whitePoint??"d65";if(r.startsWith("hsl")){const s=A(t),c=A(e);return q({h:M(s.h,c.h,n,r.endsWith("-long")),s:s.s+(c.s-s.s)*n,l:s.l+(c.l-s.l)*n})}if(r==="lab"){const s=y(t,i),c=y(e,i);return O({l:s.l+(c.l-s.l)*n,a:s.a+(c.a-s.a)*n,b:s.b+(c.b-s.b)*n},i)}if(r.startsWith("hcl")){const s=I(y(t,i)),c=I(y(e,i));return O(H({h:M(s.h,c.h,n,r.endsWith("-long")),c:s.c+(c.c-s.c)*n,l:s.l+(c.l-s.l)*n}),i)}const a=R(t),u=R(e),l=n**(o.gamma??1);if(!Number.isFinite(l))throw new RangeError("Continuous cubehelix gamma produced a nonfinite interpolation.");return U({h:M(a.h,u.h,n,r.endsWith("-long")),s:a.s+(u.s-a.s)*n,l:a.l+(u.l-a.l)*l})}function P(t){if(!B.includes(t))throw new Error(`Unsupported continuous color interpolation "${t}".`);return t}function _(t,e={}){const n={};if(e.whitePoint!==void 0){if(!["lab","hcl","hcl-long"].includes(t))throw new Error("Scale whitePoint requires Lab or HCL interpolation.");if(!["d65","d50"].includes(e.whitePoint))throw new Error("Scale whitePoint must be d65 or d50.");n.whitePoint=e.whitePoint}if(e.gamma!==void 0){if(!["cubehelix","cubehelix-long"].includes(t))throw new Error("Scale gamma requires cubehelix interpolation.");if(!Number.isFinite(e.gamma)||e.gamma<=0)throw new RangeError("Scale gamma must be a positive finite number.");n.gamma=e.gamma}return n}function G(t){if(t==="auto")return t;if(Array.isArray(t)){if($(t.length,"Sequential color range length"),t.length<2)throw new TypeError("Sequential color range requires at least two colors.");return t.forEach(w),p(t)}if(!j(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new TypeError("Sequential color range requires colors or a palette descriptor.");const e=k(t.palette);if(e.count!==void 0&&e.count<2)throw new RangeError("Sequential palette count must be an integer of at least 2.");return p({palette:e})}function Z(t){const e=G(t);return e==="auto"?S("viridis"):Array.isArray(e)?p(e.map(n=>N(w(n)))):S(e.palette)}function L(t,e,n,r,o={}){const a=(r?E(e):e)*(t.length-1),u=Math.max(0,Math.min(t.length-2,Math.floor(a))),l=u+1,s=a-u;if(n==="rgb"){const c=T(t[u]),f=T(t[l]);return`#${c.map((b,h)=>Math.round(E(b+(f[h]-b)*s,0,255)).toString(16).padStart(2,"0")).join("")}`}return N(W(t[u],t[l],s,n,o))}function v(t,e,n="rgb"){const r=P(n);if(!Array.isArray(t)||t.length<2)throw new TypeError("Color interpolation requires at least two stops.");const o=t.map(w);return L(o,e,r,!0)}function z(t,e,n="auto"){if(!(t===void 0||t==="auto")){if(e!=="sequential")throw new Error(`Scale type "${e}" does not support midpoint.`);if(!Number.isFinite(t))throw new TypeError("Scale midpoint must be finite or auto.");if(n!=="auto"&&(!Array.isArray(n)||n.length!==2||!n.every(Number.isFinite)||!(t>Math.min(...n)&&t<Math.max(...n))))throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");return t}}function V(t,e,n,r={}){const{interpolation:o="rgb",clamp:i=!1}=r;if(_(o,r),["log","pow","sqrt","symlog"].includes(r.type)){z(r.midpoint,r.type,e);const h=F(t,e,[0,1],{type:r.type,clamp:i,...r.type==="log"?{base:r.base}:{},...r.type==="pow"?{exponent:r.exponent}:{},...r.type==="symlog"?{constant:r.constant}:{},...Object.hasOwn(r,"unknown")?{unknown:NaN}:{}});return V(h,[0,1],n,{...r,type:"sequential"})}const a=Object.hasOwn(r,"unknown");if(!Array.isArray(e)||e.length!==2||!e.every(Number.isFinite))throw new TypeError("Sequential color domain must contain two finite numbers.");if(!Array.isArray(t)||!a&&!t.every(Number.isFinite))throw new TypeError("Sequential color values must be finite numbers.");if(typeof i!="boolean")throw new TypeError("Sequential color clamp must be a boolean.");const u=z(r.midpoint,"sequential",e),[l,s]=e,c=l===s,f=P(o);if(!Array.isArray(n)||n.length<2)throw new TypeError("Color interpolation requires at least two stops.");const b=n.map(w);return p(t.map(h=>{if(!Number.isFinite(h)){if(a)return r.unknown;throw new TypeError("Sequential color values must be finite numbers.")}const g=u===void 0?c?.5:C(h,l,s):(s>l?h<=u:h>=u)?C(h,l,u)/2:.5+C(h,u,s)/2;return L(b,g,f,i,r)}))}export{B as CONTINUOUS_COLOR_INTERPOLATIONS,v as interpolateColorStops,V as mapSequentialColors,_ as normalizeColorInterpolationOptions,Z as resolveSequentialColorStops,P as validateContinuousColorInterpolation,G as validateSequentialColorRange,z as validateSequentialMidpoint};

package/src/grammar/scales/colorConsumers.js

@@ -7,7 +7,7 @@ export function validateContinuousColorConsumer(layer, encoding, scale, {
   channel = "color"
 } = {}) {
   const kind = layer.mark?.type;
-  if (["log", "sqrt", "symlog"].includes(scale.type) && encoding.fieldType !== "quantitative") {
+  if (["log", "pow", "sqrt", "symlog"].includes(scale.type) && encoding.fieldType !== "quantitative") {
     throw new Error(`Scale type "${scale.type}" requires quantitative color.`);
   }
   if (channel === "stroke") {

package/src/grammar/scales/definition.js

@@ -1 +1 @@
-import{validateMeasuredRadiusScale as I}from"./radial.js";import{validateContinuousColorInterpolation as M,validateSequentialMidpoint as x}from"./color.js";import{isTransformedScaleType as T}from"./mapping.js";import{normalizeTransformParameters as D,validateTransformedDomain as F}from"./transformed.js";import{isContinuousColorScaleType as N,validateScalePropertyForType as O}from"./types.js";const k=Object.freeze(["nice","zero","clamp","reverse"]),z=Object.freeze(["base","exponent","constant"]);function m(i,t,n,e,o){return Object.hasOwn(t,e)?t[e]:!o&&Object.hasOwn(i,e)?i[e]:n[e]}function q(i,t,n,e,o){const l=Object.hasOwn(n,"padding");if(l&&(Object.hasOwn(n,"paddingInner")||Object.hasOwn(n,"paddingOuter")))throw new Error("Scale padding cannot be combined with paddingInner or paddingOuter.");if(l&&(!Number.isFinite(n.padding)||n.padding<0||n.padding>=1))throw new RangeError("Scale padding must be from 0 (inclusive) to 1 (exclusive).");const d=l?{...n,paddingInner:n.padding,paddingOuter:n.padding}:n,g=m(t,d,e,"paddingInner",o)??0,w=m(t,d,e,"paddingOuter",o)??0,c=m(t,d,e,"align",o)??.5;if(!Number.isFinite(g)||g<0||g>=1)throw new RangeError("Scale paddingInner must be from 0 (inclusive) to 1 (exclusive).");if(!Number.isFinite(w)||w<0)throw new RangeError("Scale paddingOuter must be non-negative and finite.");if(!Number.isFinite(c)||c<0||c>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{paddingInner:g,paddingOuter:w,align:c})}function A(i,t,n,e,o){const l=m(t,n,e,"padding",o)??.5,d=m(t,n,e,"align",o)??.5;if(!Number.isFinite(l)||l<0)throw new RangeError("Scale padding must be non-negative and finite.");if(!Number.isFinite(d)||d<0||d>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{padding:l,align:d})}function V({type:i,color:t=!1,previous:n={},patch:e={},defaults:o={},retainCoreOnTypeChange:l=!1,retainCompatibleOnTypeChange:d=!1,allowOrdinalBandParameters:g=!1,validateDomain:w,validateRange:c}){const s=n.type!==void 0&&n.type!==i,R=Object.hasOwn(e,"domain")?e.domain:(!s||l)&&Object.hasOwn(n,"domain")?n.domain:o.domain??"auto",P=Object.hasOwn(e,"range")?e.range:(!s||l)&&Object.hasOwn(n,"range")?n.range:o.range??"auto",r={type:i,domain:w(i,R),range:c(i,P)},u=m(n,e,o,"emptyDomain",s);if(u!==void 0){if(!["preserve","require-explicit"].includes(u))throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');r.emptyDomain=u}for(const a of k){let f=m(n,e,o,a,s);if(f===void 0&&s&&d&&Object.hasOwn(n,a))try{O(i,a),f=n[a]}catch{f=void 0}if(f!==void 0){if(typeof f!="boolean")throw new TypeError(`Scale ${a} must be a boolean.`);O(i,a),r[a]=f}}const j=Object.fromEntries(z.flatMap(a=>{const f=m(n,e,o,a,s);return f===void 0?[]:[[a,f]]}));if(T(i)){const a=D(i,j);i==="log"&&(r.base=a.base),i==="pow"&&(r.exponent=a.exponent),i==="symlog"&&(r.constant=a.constant),r.domain!=="auto"&&F(i,r.domain,j)}else for(const a of Object.keys(j))O(i,a);let b=m(n,e,o,"interpolate",s);if(i==="sequential"||t&&N(i))b===void 0&&d&&(b=n.interpolate),r.interpolate=M(b??"rgb");else if(b!==void 0)throw new Error(`Scale type "${i}" does not support interpolate.`);const S=x(m(n,e,o,"midpoint",s),i,r.domain);if(S!==void 0&&(r.midpoint=S),i==="band"||i==="ordinal"&&g)q(r,n,e,o,s);else if(i==="point")A(r,n,e,o,s);else for(const a of["paddingInner","paddingOuter","padding","align"])Object.hasOwn(e,a)&&O(i,a);const E=Object.hasOwn(e,"radialMapping")?e.radialMapping:n.radialMapping;return E!==void 0&&(r.radialMapping=E,I({...r,...Object.hasOwn(e,"unknown")||Object.hasOwn(n,"unknown")?{unknown:e.unknown??n.unknown}:{}},{allowAuto:!0})),r}export{V as normalizeScaleDefinition};
+import{validateMeasuredRadiusScale as D}from"./radial.js";import{normalizeColorInterpolationOptions as F,validateContinuousColorInterpolation as N,validateSequentialMidpoint as T}from"./color.js";import{isTransformedScaleType as k}from"./mapping.js";import{normalizeTransformParameters as q,validateTransformedDomain as A}from"./transformed.js";import{isContinuousColorScaleType as R,validateScalePropertyForType as b}from"./types.js";const p=Object.freeze(["nice","zero","clamp","reverse"]),B=Object.freeze(["base","exponent","constant"]);function f(i,l,n,e,o){return Object.hasOwn(l,e)?l[e]:!o&&Object.hasOwn(i,e)?i[e]:n[e]}function _(i,l,n,e,o){const m=Object.hasOwn(n,"padding");if(m&&(Object.hasOwn(n,"paddingInner")||Object.hasOwn(n,"paddingOuter")))throw new Error("Scale padding cannot be combined with paddingInner or paddingOuter.");if(m&&(!Number.isFinite(n.padding)||n.padding<0||n.padding>=1))throw new RangeError("Scale padding must be from 0 (inclusive) to 1 (exclusive).");const d=m?{...n,paddingInner:n.padding,paddingOuter:n.padding}:n,g=f(l,d,e,"paddingInner",o)??0,w=f(l,d,e,"paddingOuter",o)??0,c=f(l,d,e,"align",o)??.5;if(!Number.isFinite(g)||g<0||g>=1)throw new RangeError("Scale paddingInner must be from 0 (inclusive) to 1 (exclusive).");if(!Number.isFinite(w)||w<0)throw new RangeError("Scale paddingOuter must be non-negative and finite.");if(!Number.isFinite(c)||c<0||c>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{paddingInner:g,paddingOuter:w,align:c})}function $(i,l,n,e,o){const m=f(l,n,e,"padding",o)??.5,d=f(l,n,e,"align",o)??.5;if(!Number.isFinite(m)||m<0)throw new RangeError("Scale padding must be non-negative and finite.");if(!Number.isFinite(d)||d<0||d>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{padding:m,align:d})}function J({type:i,color:l=!1,previous:n={},patch:e={},defaults:o={},retainCoreOnTypeChange:m=!1,retainCompatibleOnTypeChange:d=!1,allowColorReset:g=!1,allowOrdinalBandParameters:w=!1,validateDomain:c,validateRange:I}){const s=n.type!==void 0&&n.type!==i,M=Object.hasOwn(e,"domain")?e.domain:(!s||m)&&Object.hasOwn(n,"domain")?n.domain:o.domain??"auto",x=Object.hasOwn(e,"range")?e.range:(!s||m)&&Object.hasOwn(n,"range")?n.range:o.range??"auto",r={type:i,domain:c(i,M),range:I(i,x)},u=f(n,e,o,"emptyDomain",s);if(u!==void 0){if(!["preserve","require-explicit"].includes(u))throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');r.emptyDomain=u}for(const a of p){let t=f(n,e,o,a,s);if(t===void 0&&s&&d&&Object.hasOwn(n,a))try{b(i,a),t=n[a]}catch{t=void 0}if(t!==void 0){if(typeof t!="boolean")throw new TypeError(`Scale ${a} must be a boolean.`);b(i,a),r[a]=t}}const j=Object.fromEntries(B.flatMap(a=>{const t=f(n,e,o,a,s);return t===void 0?[]:[[a,t]]}));if(k(i)){const a=q(i,j);i==="log"&&(r.base=a.base),i==="pow"&&(r.exponent=a.exponent),i==="symlog"&&(r.constant=a.constant),r.domain!=="auto"&&A(i,r.domain,j)}else for(const a of Object.keys(j))b(i,a);let O=f(n,e,o,"interpolate",s);if(i==="sequential"||l&&R(i))O===void 0&&d&&(O=n.interpolate),r.interpolate=N(O??"rgb");else if(O!==void 0)throw new Error(`Scale type "${i}" does not support interpolate.`);const z=Object.hasOwn(e,"interpolate")&&e.interpolate!==n.interpolate,S={};for(const a of["whitePoint","gamma"]){const t=Object.hasOwn(e,a)?e[a]:z?void 0:f(n,e,o,a,s&&!(d&&R(i)));t!==void 0&&!(g&&t==="auto")&&(S[a]=t)}Object.assign(r,F(r.interpolate,S));const E=T(f(n,e,o,"midpoint",s),i,r.domain);if(E!==void 0&&(r.midpoint=E),i==="band"||i==="ordinal"&&w)_(r,n,e,o,s);else if(i==="point")$(r,n,e,o,s);else for(const a of["paddingInner","paddingOuter","padding","align"])Object.hasOwn(e,a)&&b(i,a);const P=Object.hasOwn(e,"radialMapping")?e.radialMapping:n.radialMapping;return P!==void 0&&(r.radialMapping=P,D({...r,...Object.hasOwn(e,"unknown")||Object.hasOwn(n,"unknown")?{unknown:e.unknown??n.unknown}:{}},{allowAuto:!0})),r}export{J as normalizeScaleDefinition};

package/src/grammar/scales/types.js

@@ -16,7 +16,7 @@ export const SCALE_TYPES_BY_ROLE = Object.freeze({
   [SCALE_ROLES.bandPosition]: Object.freeze(["band"]),
   [SCALE_ROLES.pointPosition]: Object.freeze(["point"]),
   [SCALE_ROLES.discreteAppearance]: Object.freeze(["ordinal"]),
-  [SCALE_ROLES.continuousColor]: Object.freeze(["sequential", "log", "sqrt", "symlog"]),
+  [SCALE_ROLES.continuousColor]: Object.freeze(["sequential", "log", "pow", "sqrt", "symlog"]),
   [SCALE_ROLES.discretizedColor]: Object.freeze([
     "quantize", "quantile", "threshold"
   ])

package/src/grammar/schemas/concreteGraphic.js

@@ -53,6 +53,9 @@ export function validateConcreteGraphicValue(type, property, value) {
   if (type === "text" && property === "fontSize" && value === 0) {
     throw new RangeError("text.fontSize must be positive.");
   }
+  if (property === "blend" && !(value === "normal" || value === "difference" && type !== "circle")) {
+    throw new Error(`${type}.blend must be ${type === "circle" ? "normal" : "normal or difference"}.`);
+  }
   if (property === "opacity" && (value < 0 || value > 1)) {
     throw new RangeError(`${type}.opacity must be between 0 and 1.`);
   }

package/src/grammar/schemas/graphic.js

@@ -52,6 +52,7 @@ const GRAPHIC_PROPERTIES = Object.freeze({
     "lineJoin",
     "miterLimit",
     "opacity",
+    "blend",
     "length"
   ]),
   rect: new Set([
@@ -66,6 +67,7 @@ const GRAPHIC_PROPERTIES = Object.freeze({
     "lineJoin",
     "miterLimit",
     "opacity",
+    "blend",
     "length"
   ]),
   line: new Set([
@@ -108,6 +110,7 @@ const GRAPHIC_PROPERTIES = Object.freeze({
     "lineJoin",
     "miterLimit",
     "opacity",
+    "blend",
     "length"
   ])
 });