ggaction 0.0.17 → 0.0.18

package/src/grammar/polar.js

@@ -1,184 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { validateOptionObject } from "../core/validation.js";
-import { validatePair } from "./scales/validation.js";
-
-const POLAR_FRAME_OPTIONS = Object.freeze(["center", "radius"]);
-const POLAR_CENTER_OPTIONS = Object.freeze(["x", "y"]);
-const POLAR_RADIUS_OPTIONS = Object.freeze(["unit", "value"]);
-const POLAR_RADIUS_UNITS = new Set(["fraction", "px"]);
-
-function validateBounds(bounds) {
-  if (
-    !isPlainObject(bounds) ||
-    ![bounds.x, bounds.y, bounds.width, bounds.height].every(Number.isFinite) ||
-    bounds.width < 0 ||
-    bounds.height < 0
-  ) {
-    throw new TypeError(
-      "Polar geometry requires finite, non-negative graphical bounds."
-    );
-  }
-  return bounds;
-}
-
-function finiteUnitInterval(value, label) {
-  if (!Number.isFinite(value) || value < 0 || value > 1) {
-    throw new RangeError(`${label} must be a finite number from 0 through 1.`);
-  }
-  return value;
-}
-
-export function normalizePolarFrameOptions(value) {
-  if (value === "auto") return value;
-  if (!isPlainObject(value)) {
-    throw new TypeError('Polar frame must be "auto" or a plain object.');
-  }
-  validateOptionObject(value, POLAR_FRAME_OPTIONS, "polar frame");
-  const center = value.center ?? {};
-  if (!isPlainObject(center)) {
-    throw new TypeError("Polar frame center must be a plain object.");
-  }
-  validateOptionObject(center, POLAR_CENTER_OPTIONS, "polar frame center");
-  const radius = value.radius ?? { unit: "fraction", value: 1 };
-  if (!isPlainObject(radius)) {
-    throw new TypeError("Polar frame radius must be a plain object.");
-  }
-  validateOptionObject(radius, POLAR_RADIUS_OPTIONS, "polar frame radius", {
-    allowEmpty: false,
-    emptyError: TypeError
-  });
-  if (!POLAR_RADIUS_UNITS.has(radius.unit)) {
-    throw new Error(`Unknown Polar frame radius unit "${radius.unit}".`);
-  }
-  if (!Number.isFinite(radius.value) || radius.value <= 0) {
-    throw new RangeError("Polar frame radius must be a positive finite number.");
-  }
-  if (radius.unit === "fraction" && radius.value > 1) {
-    throw new RangeError("Polar frame radius fraction must not exceed 1.");
-  }
-  return cloneAndFreeze({
-    center: {
-      x: finiteUnitInterval(center.x ?? 0.5, "Polar frame center x"),
-      y: finiteUnitInterval(center.y ?? 0.5, "Polar frame center y")
-    },
-    radius: {
-      unit: radius.unit,
-      value: radius.value
-    }
-  });
-}
-
-export function resolvePolarFrame(bounds, requestedFrame = "auto") {
-  validateBounds(bounds);
-  if (requestedFrame === undefined || requestedFrame === "auto") {
-    return cloneAndFreeze({
-      centerX: bounds.x + bounds.width / 2,
-      centerY: bounds.y + bounds.height / 2,
-      availableRadius: Math.min(bounds.width, bounds.height) / 2
-    });
-  }
-  const requested = normalizePolarFrameOptions(requestedFrame);
-  const centerX = bounds.x + bounds.width * requested.center.x;
-  const centerY = bounds.y + bounds.height * requested.center.y;
-  const maximumRadius = Math.min(
-    centerX - bounds.x,
-    bounds.x + bounds.width - centerX,
-    centerY - bounds.y,
-    bounds.y + bounds.height - centerY
-  );
-  if (!Number.isFinite(maximumRadius) || maximumRadius <= 0) {
-    throw new RangeError(
-      "Polar frame center must leave a positive radius inside its bounds."
-    );
-  }
-  const availableRadius = requested.radius.unit === "fraction"
-    ? maximumRadius * requested.radius.value
-    : requested.radius.value;
-  if (availableRadius > maximumRadius) {
-    throw new RangeError(
-      `Polar frame radius ${availableRadius} exceeds the maximum radius ${maximumRadius}.`
-    );
-  }
-  return cloneAndFreeze({
-    centerX,
-    centerY,
-    availableRadius
-  });
-}
-
-export function validateThetaRange(range) {
-  if (range === "auto") return range;
-  const validated = validatePair(range, "Theta scale range");
-  if (Math.abs(validated[1] - validated[0]) > 360) {
-    throw new RangeError("Theta scale range span must not exceed 360 degrees.");
-  }
-  return validated;
-}
-
-export function validateRadialRange(range, availableRadius) {
-  if (range === "auto") return range;
-  const validated = validatePair(range, "Radius scale range");
-  if (validated.some(value => value < 0)) {
-    throw new RangeError("Radius scale range values must be non-negative.");
-  }
-  if (
-    availableRadius !== undefined &&
-    validated.some(value => value > availableRadius)
-  ) {
-    throw new RangeError(
-      `Radius scale range must fit within the available radius ${availableRadius}.`
-    );
-  }
-  return validated;
-}
-
-export function resolvePolarScaleRange(range, channel, bounds, frame) {
-  if (channel === "theta") {
-    return range === "auto"
-      ? cloneAndFreeze([0, 360])
-      : validateThetaRange(range);
-  }
-  if (channel !== "radius") {
-    throw new Error(`Unknown Polar position channel "${channel}".`);
-  }
-  const resolvedFrame = frame ?? resolvePolarFrame(bounds);
-  return range === "auto"
-    ? cloneAndFreeze([0, resolvedFrame.availableRadius])
-    : validateRadialRange(range, resolvedFrame.availableRadius);
-}
-
-export function polarDirection(theta) {
-  if (!Number.isFinite(theta)) {
-    throw new TypeError("Polar theta must be a finite number of degrees.");
-  }
-  const angle = theta * Math.PI / 180;
-  return cloneAndFreeze({
-    x: Math.sin(angle),
-    y: -Math.cos(angle)
-  });
-}
-
-export function polarToCartesian({ theta, radius, frame }) {
-  const direction = polarDirection(theta);
-  if (!Number.isFinite(radius) || radius < 0) {
-    throw new TypeError("Polar radius must be a non-negative finite number.");
-  }
-  const resolvedFrame = frame?.availableRadius === undefined
-    ? resolvePolarFrame(frame)
-    : frame;
-  if (
-    ![resolvedFrame.centerX, resolvedFrame.centerY,
-      resolvedFrame.availableRadius].every(Number.isFinite)
-  ) {
-    throw new TypeError("Polar frame must contain finite geometry.");
-  }
-  if (radius > resolvedFrame.availableRadius) {
-    throw new RangeError(
-      `Polar radius ${radius} exceeds the available radius ${resolvedFrame.availableRadius}.`
-    );
-  }
-  return cloneAndFreeze({
-    x: resolvedFrame.centerX + radius * direction.x,
-    y: resolvedFrame.centerY + radius * direction.y
-  });
-}
+import{cloneAndFreeze as n,isPlainObject as l}from"../core/immutable.js";import{validateOptionObject as u}from"../core/validation.js";import{validatePair as c}from"./scales/validation.js";const w=Object.freeze(["center","radius","overflow"]),h=Object.freeze(["x","y"]),d=Object.freeze(["unit","value"]),p=new Set(["fraction","px"]);function v(e){if(!l(e)||![e.x,e.y,e.width,e.height].every(Number.isFinite)||e.width<0||e.height<0)throw new TypeError("Polar geometry requires finite, non-negative graphical bounds.");return e}function s(e,r){if(!Number.isFinite(e)||e<0||e>1)throw new RangeError(`${r} must be a finite number from 0 through 1.`);return e}function R(e){if(e==="auto")return e;if(!l(e))throw new TypeError('Polar frame must be "auto" or a plain object.');if(u(e,w,"polar frame"),e.overflow!==void 0&&!["error","allow"].includes(e.overflow))throw new Error("Polar frame overflow must be error or allow.");const r=e.center??{};if(!l(r))throw new TypeError("Polar frame center must be a plain object.");u(r,h,"polar frame center");const t=e.radius??{unit:"fraction",value:1};if(!l(t))throw new TypeError("Polar frame radius must be a plain object.");if(u(t,d,"polar frame radius",{allowEmpty:!1,emptyError:TypeError}),!p.has(t.unit))throw new Error(`Unknown Polar frame radius unit "${t.unit}".`);if(!Number.isFinite(t.value)||t.value<=0)throw new RangeError("Polar frame radius must be a positive finite number.");if(t.unit==="fraction"&&t.value>1)throw new RangeError("Polar frame radius fraction must not exceed 1.");return n({center:{x:s(r.x??.5,"Polar frame center x"),y:s(r.y??.5,"Polar frame center y")},radius:{unit:t.unit,value:t.value},...e.overflow==="allow"?{overflow:"allow"}:{}})}function m(e,r="auto"){if(v(e),r===void 0||r==="auto")return n({centerX:e.x+e.width/2,centerY:e.y+e.height/2,availableRadius:Math.min(e.width,e.height)/2});const t=R(r),a=e.x+e.width*t.center.x,i=e.y+e.height*t.center.y,o=Math.min(a-e.x,e.x+e.width-a,i-e.y,e.y+e.height-i);if(!Number.isFinite(o)||o<=0)throw new RangeError("Polar frame center must leave a positive radius inside its bounds.");const f=t.radius.unit==="fraction"?o*t.radius.value:t.radius.value;if(f>o&&t.overflow!=="allow")throw new RangeError(`Polar frame radius ${f} exceeds the maximum radius ${o}.`);return n({centerX:a,centerY:i,availableRadius:f})}function P(e){if(e==="auto")return e;const r=c(e,"Theta scale range");if(Math.abs(r[1]-r[0])>360)throw new RangeError("Theta scale range span must not exceed 360 degrees.");return r}function x(e,r){if(e==="auto")return e;const t=c(e,"Radius scale range");if(t.some(a=>a<0))throw new RangeError("Radius scale range values must be non-negative.");if(r!==void 0&&t.some(a=>a>r))throw new RangeError(`Radius scale range must fit within the available radius ${r}.`);return t}function T(e,r,t,a){if(r==="theta")return e==="auto"?n([0,360]):P(e);if(r!=="radius")throw new Error(`Unknown Polar position channel "${r}".`);const i=a??m(t);return e==="auto"?n([0,i.availableRadius]):x(e,i.availableRadius)}function y(e){if(!Number.isFinite(e))throw new TypeError("Polar theta must be a finite number of degrees.");const r=e*Math.PI/180;return n({x:Math.sin(r),y:-Math.cos(r)})}function b({theta:e,radius:r,frame:t}){const a=y(e);if(!Number.isFinite(r)||r<0)throw new TypeError("Polar radius must be a non-negative finite number.");const i=t?.availableRadius===void 0?m(t):t;if(![i.centerX,i.centerY,i.availableRadius].every(Number.isFinite))throw new TypeError("Polar frame must contain finite geometry.");if(r>i.availableRadius)throw new RangeError(`Polar radius ${r} exceeds the available radius ${i.availableRadius}.`);return n({x:i.centerX+r*a.x,y:i.centerY+r*a.y})}export{R as normalizePolarFrameOptions,y as polarDirection,b as polarToCartesian,m as resolvePolarFrame,T as resolvePolarScaleRange,x as validateRadialRange,P as validateThetaRange};

package/src/grammar/positionCompatibility.js

@@ -6,14 +6,14 @@ export const POSITION_FIELD_COMPATIBILITY = Object.freeze({
     radius: Object.freeze(["quantitative"])
   }),
   line: Object.freeze({
-    x: Object.freeze(["quantitative", "temporal"]),
+    x: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     y: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     theta: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     radius: Object.freeze(["quantitative"])
   }),
   area: Object.freeze({
-    x: Object.freeze(["quantitative", "temporal"]),
-    y: Object.freeze(["quantitative", "temporal"])
+    x: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
+    y: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"])
   }),
   arc: Object.freeze({
     theta: Object.freeze(["quantitative", "ordinal", "nominal"]),

package/src/grammar/regression/derive.js

@@ -24,6 +24,7 @@ export function deriveRegression(values, {
   method,
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   confidence,
@@ -43,6 +44,7 @@ export function deriveRegression(values, {
     method,
     degree,
     span,
+    robustIterations,
     confidenceMethod,
     level,
     confidence,
@@ -102,7 +104,11 @@ export function deriveRegression(values, {
       const size = parameters.degree + 1;
       work += groupRows.length * size ** 2 + size ** 3;
     } else if (parameters.method === "loess") {
-      work += groupRows.length * xValues.length *
+      const observedSet = new Set(observedX);
+      const newPredictions = predict === undefined ? 0 :
+        xValues.filter(value => !observedSet.has(value)).length;
+      work += groupRows.length *
+        (observedX.length * (1 + (parameters.robustIterations ?? 0)) + newPredictions) *
         Math.ceil(Math.log2(groupRows.length + 1));
     }
     validateWorkLimit(work, "Regression computation");

package/src/grammar/regression/models.js

@@ -376,7 +376,56 @@ function weightedPrediction(items, x, y, xValue, xScale = 1, yScale = 1) {
   return meanY - (variance === 0 ? 0 : covariance / variance) * meanDifference;
 }
 
-function fitLoessGroup(rows, { x, y, group, span }) {
+function applyResidualWeights(neighbors, residualWeights) {
+  if (!neighbors.some(item => item.weight > 0)) {
+    neighbors = neighbors.map(item => ({ ...item, weight: 1 }));
+  }
+  if (residualWeights === undefined) return neighbors;
+  const weighted = neighbors.map(item => ({
+    ...item, weight: item.weight * residualWeights[item.index]
+  }));
+  return weighted.some(item => item.weight > 0) ? weighted : neighbors;
+}
+
+function loessPrediction(rows, {
+  x, y, xValue, xScale, yScale, neighborCount, residualWeights, scaled = false
+}, label) {
+  const rawDistances = rows.map(row => Math.abs(row[x] - xValue));
+  const scaledDistances = scaled || rawDistances.some(value => !Number.isFinite(value));
+  const neighbors = rows
+    .map((row, index) => ({
+      row,
+      index,
+      distance: scaledDistances
+        ? Math.abs(row[x] / xScale - xValue / xScale)
+        : rawDistances[index]
+    }))
+    .sort((left, right) =>
+      left.distance - right.distance || left.index - right.index
+    )
+    .slice(0, neighborCount);
+  const radius = neighbors.at(-1).distance;
+  let weighted = neighbors.map(neighbor => ({
+    ...neighbor,
+    weight: radius === 0
+      ? 1
+      : (1 - (neighbor.distance / radius) ** 3) ** 3
+  }));
+  weighted = applyResidualWeights(weighted, residualWeights);
+  const ordinary = weightedPrediction(weighted, x, y, xValue);
+  return {
+    prediction: Number.isFinite(ordinary)
+      ? ordinary
+      : restoreFiniteScale(
+          weightedPrediction(weighted, x, y, xValue, xScale, yScale),
+          yScale,
+          label
+        ),
+    neighborIndices: weighted.map(item => item.index)
+  };
+}
+
+function fitLoessGroup(rows, { x, y, group, span, robustIterations = 0 }) {
   const groupLabel = group === undefined ? "all" : String(group);
   const label = `LOESS regression group "${groupLabel}"`;
   if (rows.length < 2 || new Set(rows.map(row => row[x])).size < 2) {
@@ -390,64 +439,42 @@ function fitLoessGroup(rows, { x, y, group, span }) {
     .sort((left, right) => left - right);
   const xScale = maximumMagnitude(rows.map(row => row[x])) || 1;
   const yScale = maximumMagnitude(rows.map(row => row[y])) || 1;
-  const fits = xValues.map(xValue => {
-    const rawDistances = rows.map(row => Math.abs(row[x] - xValue));
-    const scaledDistances = rawDistances.some(value => !Number.isFinite(value));
-    const neighbors = rows
-      .map((row, index) => ({
-        row,
-        index,
-        distance: scaledDistances
-          ? Math.abs(row[x] / xScale - xValue / xScale)
-          : rawDistances[index]
-      }))
-      .sort((left, right) =>
-        left.distance - right.distance || left.index - right.index
-      )
-      .slice(0, neighborCount);
-    const radius = neighbors.at(-1).distance;
-    const weighted = neighbors.map(neighbor => ({
-      ...neighbor,
-      weight: radius === 0
-        ? 1
-        : (1 - (neighbor.distance / radius) ** 3) ** 3
-    }));
-    const ordinary = weightedPrediction(weighted, x, y, xValue);
-    return {
-      x: xValue,
-      prediction: Number.isFinite(ordinary)
-        ? ordinary
-        : restoreFiniteScale(
-            weightedPrediction(weighted, x, y, xValue, xScale, yScale),
-            yScale,
-            `${label} prediction`
-          ),
-      neighborIndices: weighted.map(item => item.index)
-    };
-  });
-  return { count: rows.length, span, neighborCount, fits, rows, x, y, xScale, yScale };
+  const fitAtObserved = residualWeights => xValues.map(xValue => ({
+    x: xValue,
+    ...loessPrediction(rows, {
+      x, y, xValue, xScale, yScale, neighborCount, residualWeights
+    }, `${label} prediction`)
+  }));
+  let fits = fitAtObserved();
+  let residualWeights;
+  for (let iteration = 0; iteration < robustIterations; iteration += 1) {
+    const predictions = new Map(fits.map(fit => [fit.x, fit.prediction]));
+    const residuals = rows.map(row => Math.abs(row[y] / yScale - predictions.get(row[x]) / yScale));
+    const sorted = [...residuals].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 === 0
+      ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+    const tolerance = 64 * Number.EPSILON;
+    const cutoff = 6 * median;
+    const nextWeights = residuals.map(residual => {
+      if (cutoff <= tolerance) return residual <= tolerance ? 1 : 0;
+      const ratio = residual / cutoff;
+      return ratio >= 1 ? 0 : (1 - ratio * ratio) ** 2;
+    });
+    if (nextWeights.every((weight, index) => weight === (residualWeights?.[index] ?? 1))) break;
+    residualWeights = nextWeights;
+    fits = fitAtObserved(residualWeights);
+  }
+  return { count: rows.length, span, neighborCount, fits, rows, x, y, xScale, yScale,
+    ...(robustIterations === 0 ? {} : { robustIterations, residualWeights: residualWeights ?? rows.map(() => 1) }) };
 }
 
 function predictLoessAt(model, xValue) {
   const found = model.fits.find(fit => fit.x === xValue);
   if (found !== undefined) return found.prediction;
-  const neighbors = model.rows.map((row, index) => ({
-    row,
-    index,
-    distance: Math.abs(row[model.x] / model.xScale - xValue / model.xScale)
-  })).sort((left, right) => left.distance - right.distance || left.index - right.index)
-    .slice(0, model.neighborCount);
-  const radius = neighbors.at(-1).distance;
-  const weighted = neighbors.map(neighbor => ({
-    ...neighbor,
-    weight: radius === 0 ? 1 : (1 - (neighbor.distance / radius) ** 3) ** 3
-  }));
-  const ordinary = weightedPrediction(weighted, model.x, model.y, xValue);
-  return Number.isFinite(ordinary) ? ordinary : restoreFiniteScale(
-    weightedPrediction(weighted, model.x, model.y, xValue, model.xScale, model.yScale),
-    model.yScale,
-    "LOESS regression prediction"
-  );
+  return loessPrediction(model.rows, {
+    ...model, xValue, scaled: true
+  }, "LOESS regression prediction").prediction;
 }
 
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
@@ -472,7 +499,8 @@ export function fitRegressionGroup(rows, { x, y, group, parameters }) {
       interval: parameters.interval
     });
   }
-  return fitLoessGroup(rows, { x, y, group, span: parameters.span });
+  return fitLoessGroup(rows, { x, y, group, span: parameters.span,
+    robustIterations: parameters.robustIterations });
 }
 
 export function predictRegressionAt(model, xValue, parameters) {

package/src/grammar/regression/parameters.js

@@ -45,6 +45,7 @@ export function normalizeRegressionParameters({
   method = "linear",
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   confidence,
@@ -69,7 +70,15 @@ export function normalizeRegressionParameters({
         "Regression LOESS span must be greater than zero and at most one."
       );
     }
-    return cloneAndFreeze({ method, span: resolvedSpan });
+    const iterations = robustIterations === undefined ? 0 : robustIterations;
+    if (!Number.isInteger(iterations) || iterations < 0 || iterations > 32) {
+      throw new RangeError("LOESS robustIterations must be an integer in [0, 32].");
+    }
+    return cloneAndFreeze({ method, span: resolvedSpan,
+      ...(iterations === 0 ? {} : { robustIterations: iterations }) });
+  }
+  if (robustIterations !== undefined) {
+    throw new Error("Regression robustIterations requires the loess method.");
   }
   if (span !== undefined) {
     throw new Error("Regression span requires the loess method.");
@@ -140,7 +149,7 @@ export function validateRegressionTransform(transform) {
   const supported = [
     "type", "method", "x", "y", "groupBy", "confidenceMethod", "level",
     "confidence", "interval",
-    "degree", "span", "predict", "missing"
+    "degree", "span", "robustIterations", "predict", "missing"
   ];
   const unknown = Object.keys(transform).find(key => !supported.includes(key));
   if (unknown !== undefined) {
@@ -166,6 +175,7 @@ export function validateRegressionTransform(transform) {
     method: transform.method,
     degree: transform.degree,
     span: transform.span,
+    robustIterations: transform.robustIterations,
     confidenceMethod: transform.confidenceMethod,
     level: transform.level,
     confidence: transform.confidence,
@@ -202,7 +212,8 @@ export function normalizeRegressionTransform(args = {}) {
       ? { degree: parameters.degree }
       : {}),
     ...(parameters.method === "loess"
-      ? { span: parameters.span }
+      ? { span: parameters.span, ...(parameters.robustIterations === undefined
+          ? {} : { robustIterations: parameters.robustIterations }) }
       : parameters.interval === false ? { interval: false } : {
           confidenceMethod: parameters.confidenceMethod,
           level: parameters.level,

package/src/grammar/roundedRect.js

@@ -5,8 +5,12 @@ import {
 } from "./strokeStyle.js";
 
 export const ROUNDED_RECT_K = 4 * (Math.sqrt(2) - 1) / 3;
+export const RECT_RADIUS_PROPERTIES = Object.freeze([
+  "cornerRadius", "cornerRadiusTopLeft", "cornerRadiusTopRight",
+  "cornerRadiusBottomRight", "cornerRadiusBottomLeft"
+]);
 export const RECT_STYLE_PROPERTIES = Object.freeze([
-  "cornerRadius",
+  ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -17,12 +21,12 @@ function requireFinite(value, property) {
   return value;
 }
 
-export function validateCornerRadius(value, label = "Rect style") {
+export function validateCornerRadius(value, label = "Rect style", property = "cornerRadius") {
   if (!Number.isFinite(value)) {
-    throw new TypeError(`${label} cornerRadius must be a finite number.`);
+    throw new TypeError(`${label} ${property} must be a finite number.`);
   }
   if (value < 0) {
-    throw new RangeError(`${label} cornerRadius must not be negative.`);
+    throw new RangeError(`${label} ${property} must not be negative.`);
   }
   return value;
 }
@@ -33,9 +37,9 @@ export function requestedRectStyleDetails(request = {}, label = "Rect style") {
   }
   return freezeOwned({
     ...requestedStrokeDetails(request, label),
-    ...(Object.hasOwn(request, "cornerRadius")
-      ? { cornerRadius: validateCornerRadius(request.cornerRadius, label) }
-      : {})
+    ...Object.fromEntries(RECT_RADIUS_PROPERTIES
+      .filter(property => Object.hasOwn(request, property))
+      .map(property => [property, validateCornerRadius(request[property], label, property)]))
   });
 }
 
@@ -65,60 +69,48 @@ export function resolveRoundedRectRadius(width, height, requestedRadius) {
   return Math.min(requestedRadius, width / 2, height / 2);
 }
 
+export function hasRectRadius(style = {}) {
+  return RECT_RADIUS_PROPERTIES.some(property => Object.hasOwn(style, property));
+}
+
+function resolveCornerRadii(width, height, requested) {
+  const style = typeof requested === "number" ? { cornerRadius: requested } : requested;
+  const details = requestedRectStyleDetails(style, "Rounded rect");
+  return RECT_RADIUS_PROPERTIES.slice(1).map(property => resolveRoundedRectRadius(
+    width, height, details[property] ?? details.cornerRadius ?? 0
+  ));
+}
+
 export function roundedRectCommands({ x, y, width, height, radius }) {
   const geometry = normalizeRectGeometry({ x, y, width, height });
-  const r = resolveRoundedRectRadius(
-    geometry.width,
-    geometry.height,
-    radius
-  );
-  if (!(r > 0)) {
+  const [tl, tr, br, bl] = resolveCornerRadii(geometry.width, geometry.height, radius);
+  if (![tl, tr, br, bl].some(value => value > 0)) {
     throw new RangeError("Rounded rect commands require a positive resolved radius.");
   }
   const right = geometry.x + geometry.width;
   const bottom = geometry.y + geometry.height;
-  const c = ROUNDED_RECT_K * r;
+  const k = ROUNDED_RECT_K;
   return freezeOwned([
-    { op: "M", x: geometry.x + r, y: geometry.y },
-    { op: "L", x: right - r, y: geometry.y },
+    { op: "M", x: geometry.x + tl, y: geometry.y },
+    { op: "L", x: right - tr, y: geometry.y },
     {
-      op: "C",
-      x1: right - r + c,
-      y1: geometry.y,
-      x2: right,
-      y2: geometry.y + r - c,
-      x: right,
-      y: geometry.y + r
+      op: "C", x1: right - tr + k * tr, y1: geometry.y,
+      x2: right, y2: geometry.y + tr - k * tr, x: right, y: geometry.y + tr
     },
-    { op: "L", x: right, y: bottom - r },
+    { op: "L", x: right, y: bottom - br },
     {
-      op: "C",
-      x1: right,
-      y1: bottom - r + c,
-      x2: right - r + c,
-      y2: bottom,
-      x: right - r,
-      y: bottom
+      op: "C", x1: right, y1: bottom - br + k * br,
+      x2: right - br + k * br, y2: bottom, x: right - br, y: bottom
     },
-    { op: "L", x: geometry.x + r, y: bottom },
+    { op: "L", x: geometry.x + bl, y: bottom },
     {
-      op: "C",
-      x1: geometry.x + r - c,
-      y1: bottom,
-      x2: geometry.x,
-      y2: bottom - r + c,
-      x: geometry.x,
-      y: bottom - r
+      op: "C", x1: geometry.x + bl - k * bl, y1: bottom,
+      x2: geometry.x, y2: bottom - bl + k * bl, x: geometry.x, y: bottom - bl
     },
-    { op: "L", x: geometry.x, y: geometry.y + r },
+    { op: "L", x: geometry.x, y: geometry.y + tl },
     {
-      op: "C",
-      x1: geometry.x,
-      y1: geometry.y + r - c,
-      x2: geometry.x + r - c,
-      y2: geometry.y,
-      x: geometry.x + r,
-      y: geometry.y
+      op: "C", x1: geometry.x, y1: geometry.y + tl - k * tl,
+      x2: geometry.x + tl - k * tl, y2: geometry.y, x: geometry.x + tl, y: geometry.y
     },
     { op: "Z" }
   ].map(command => freezeOwned(command)));
@@ -129,15 +121,11 @@ export function materializeRectItem(properties, requestedRadius = 0) {
     throw new TypeError("Rounded rect item properties must be a plain object.");
   }
   const geometry = normalizeRectGeometry(properties);
-  const radius = resolveRoundedRectRadius(
-    geometry.width,
-    geometry.height,
-    requestedRadius
-  );
+  const radii = resolveCornerRadii(geometry.width, geometry.height, requestedRadius);
   const appearance = Object.fromEntries(Object.entries(properties).filter(
     ([key]) => !["x", "y", "width", "height"].includes(key)
   ));
-  return radius === 0
+  return radii.every(radius => radius === 0)
     ? freezeOwned({
         type: "rect",
         properties: freezeOwned({ ...geometry, ...appearance })
@@ -145,7 +133,7 @@ export function materializeRectItem(properties, requestedRadius = 0) {
     : freezeOwned({
         type: "path",
         properties: freezeOwned({
-          commands: roundedRectCommands({ ...geometry, radius }),
+          commands: roundedRectCommands({ ...geometry, radius: requestedRadius }),
           ...appearance
         })
       });