ggaction 0.0.2 → 0.0.4

package/src/grammar/regression/parameters.js

@@ -0,0 +1,106 @@
+import { cloneAndFreeze } from "../../core/immutable.js";
+
+export function requireRegressionField(field, label) {
+  if (typeof field !== "string" || field.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return field;
+}
+
+export function normalizeRegressionParameters({
+  method = "linear",
+  degree,
+  span,
+  confidence,
+  interval
+} = {}) {
+  if (!["linear", "polynomial", "loess"].includes(method)) {
+    throw new Error(`Unsupported regression method "${method}".`);
+  }
+  if (method === "loess") {
+    if (degree !== undefined) {
+      throw new Error("Regression degree requires the polynomial method.");
+    }
+    if (confidence !== undefined || interval !== undefined) {
+      throw new Error("LOESS regression does not support confidence intervals.");
+    }
+    const resolvedSpan = span ?? 0.75;
+    if (!Number.isFinite(resolvedSpan) || resolvedSpan <= 0 || resolvedSpan > 1) {
+      throw new RangeError(
+        "Regression LOESS span must be greater than zero and at most one."
+      );
+    }
+    return cloneAndFreeze({ method, span: resolvedSpan });
+  }
+  if (span !== undefined) {
+    throw new Error("Regression span requires the loess method.");
+  }
+  const resolvedConfidence = confidence ?? 0.95;
+  if (
+    !Number.isFinite(resolvedConfidence) ||
+    resolvedConfidence <= 0 ||
+    resolvedConfidence >= 1
+  ) {
+    throw new RangeError("Regression confidence must be between 0 and 1.");
+  }
+  const resolvedInterval = interval ?? "mean";
+  if (!["mean", "prediction"].includes(resolvedInterval)) {
+    throw new Error(`Unsupported regression interval "${resolvedInterval}".`);
+  }
+  if (method === "polynomial") {
+    const resolvedDegree = degree ?? 2;
+    if (!Number.isInteger(resolvedDegree) || resolvedDegree < 1) {
+      throw new RangeError(
+        "Regression polynomial degree must be a positive integer."
+      );
+    }
+    return cloneAndFreeze({
+      method,
+      degree: resolvedDegree,
+      confidence: resolvedConfidence,
+      interval: resolvedInterval
+    });
+  }
+  if (degree !== undefined) {
+    throw new Error("Regression degree requires the polynomial method.");
+  }
+  return cloneAndFreeze({
+    method,
+    confidence: resolvedConfidence,
+    interval: resolvedInterval
+  });
+}
+
+export function validateRegressionTransform(transform) {
+  const supported = [
+    "type", "method", "x", "y", "groupBy", "confidence", "interval",
+    "degree", "span"
+  ];
+  const unknown = Object.keys(transform).find(key => !supported.includes(key));
+  if (unknown !== undefined) {
+    throw new Error(`Unknown regression transform property "${unknown}".`);
+  }
+  if (transform.type !== "regression") {
+    throw new Error(`Unsupported regression transform "${transform.type}".`);
+  }
+  requireRegressionField(transform.x, "Regression x field");
+  requireRegressionField(transform.y, "Regression y field");
+  if (transform.groupBy !== undefined) {
+    requireRegressionField(transform.groupBy, "Regression groupBy field");
+  }
+  const normalized = normalizeRegressionParameters({
+    method: transform.method,
+    degree: transform.degree,
+    span: transform.span,
+    confidence: transform.confidence,
+    interval: transform.interval
+  });
+  if (normalized.method === "loess") return transform;
+  if (!Number.isFinite(transform.confidence)) {
+    throw new RangeError("Regression confidence must be between 0 and 1.");
+  }
+  if (transform.interval === undefined) {
+    throw new Error(`Unsupported regression interval "${transform.interval}".`);
+  }
+  return transform;
+}

package/src/grammar/rules.js

@@ -6,7 +6,7 @@ import {
   readQuantitativeField,
   readTemporalField,
   validateSemanticFieldType
-} from "./scales.js";
+} from "./scales/index.js";
 
 const ENDPOINT_CHANNELS = Object.freeze(["x", "y", "x2", "y2"]);
 const VALUE_CHANNELS = Object.freeze([

package/src/grammar/scales/color.js

@@ -277,8 +277,10 @@ export function validateSequentialColorRange(value) {
     throw new TypeError("Sequential color range requires colors or a palette descriptor.");
   }
   const palette = normalizePalette(value.palette);
-  if (palette.count !== undefined) {
-    throw new Error("Continuous palette does not accept count.");
+  if (palette.count !== undefined && palette.count < 2) {
+    throw new RangeError(
+      "Sequential palette count must be an integer of at least 2."
+    );
   }
   return cloneAndFreeze({ palette });
 }

package/src/grammar/scales/continuous.js

@@ -1,4 +1,6 @@
 import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
+import { POLAR_POSITION_CHANNELS } from "../../core/vocabulary.js";
+import { resolvePolarScaleRange } from "../polar.js";
 import { niceTimeDomain } from "./temporal.js";
 import {
   validatePair,
@@ -66,8 +68,11 @@ export function resolveContinuousDomain({ domain, values, type, nice, zero }) {
 }
 
 export function resolveScaleRange(range, channel, bounds) {
-  const validated = validateScaleRange(range);
   validatePositionChannel(channel);
+  if (POLAR_POSITION_CHANNELS.includes(channel)) {
+    return resolvePolarScaleRange(range, channel, bounds);
+  }
+  const validated = validateScaleRange(range);
   if (validated !== "auto") return validated;
   if (
     !isPlainObject(bounds) ||

package/src/grammar/scales/fields.js

@@ -22,6 +22,13 @@ export function validateNominalFieldType(fieldType) {
   return fieldType;
 }
 
+export function validateCategoricalFieldType(fieldType) {
+  if (!["nominal", "ordinal"].includes(fieldType)) {
+    throw new Error(`Unsupported categorical field type "${fieldType}".`);
+  }
+  return fieldType;
+}
+
 export function validateSemanticFieldType(fieldType) {
   if (!["quantitative", "nominal", "ordinal", "temporal"].includes(fieldType)) {
     throw new Error(`Unsupported semantic field type "${fieldType}".`);

package/src/grammar/scales/ordinal.js

@@ -151,11 +151,14 @@ export function resolveOrdinalOffsetScale({
   range,
   parentBandwidth,
   paddingInner = 0,
-  paddingOuter = 0
+  paddingOuter = 0,
+  channel = "xOffset"
 }) {
   const resolvedDomain = resolveOrdinalDomain(domain, values);
   if (!Number.isFinite(parentBandwidth) || parentBandwidth <= 0) {
-    throw new Error("Automatic xOffset range requires a positive x bandwidth.");
+    throw new Error(
+      `Automatic ${channel} range requires a positive ${channel[0]} bandwidth.`
+    );
   }
   const resolvedRange = range === "auto"
     ? validatePair([0, parentBandwidth], "Offset scale range")

package/src/grammar/scales/policies.js

@@ -3,7 +3,7 @@ import { POINT_SHAPES } from "../pointShapes.js";
 import { normalizeStrokeDashPattern } from "./appearance.js";
 
 export function validateScaleUnknown(channel, value) {
-  if (["x", "y", "xOffset"].includes(channel)) {
+  if (["x", "y", "xOffset", "yOffset"].includes(channel)) {
     if (!Number.isFinite(value)) {
       throw new TypeError(`Scale unknown for ${channel} must be a finite number.`);
     }

package/src/grammar/schemas/graphic.js

@@ -11,7 +11,7 @@ const DRAWABLE_TYPES = new Set([
 ]);
 const STRUCTURAL_TYPES = new Set(["canvas"]);
 const GRAPHIC_PROPERTIES = Object.freeze({
-  canvas: new Set(["width", "height", "background"]),
+  canvas: new Set(["x", "y", "width", "height", "background"]),
   collection: new Set([
     "items",
     "x",

package/src/grammar/schemas/graphicBounds.js

@@ -11,6 +11,69 @@ function unionBounds(bounds) {
   };
 }
 
+function cubicValue(start, control1, control2, end, t) {
+  const remaining = 1 - t;
+  return remaining ** 3 * start +
+    3 * remaining ** 2 * t * control1 +
+    3 * remaining * t ** 2 * control2 +
+    t ** 3 * end;
+}
+
+function cubicExtrema(start, control1, control2, end) {
+  const quadratic = 3 * (-start + 3 * control1 - 3 * control2 + end);
+  const linear = 2 * (3 * start - 6 * control1 + 3 * control2);
+  const constant = 3 * (control1 - start);
+  const epsilon = Number.EPSILON * 64 * Math.max(
+    1,
+    Math.abs(quadratic),
+    Math.abs(linear),
+    Math.abs(constant)
+  );
+  if (Math.abs(quadratic) <= epsilon) {
+    if (Math.abs(linear) <= epsilon) return [];
+    const root = -constant / linear;
+    return root > 0 && root < 1 ? [root] : [];
+  }
+  const discriminant = linear ** 2 - 4 * quadratic * constant;
+  if (discriminant < -epsilon) return [];
+  const root = Math.sqrt(Math.max(0, discriminant));
+  return [
+    (-linear - root) / (2 * quadratic),
+    (-linear + root) / (2 * quadratic)
+  ].filter(value => value > 0 && value < 1);
+}
+
+function pathPoints(commands) {
+  const points = [];
+  let current;
+  for (const command of commands) {
+    if (command.op === "M" || command.op === "L") {
+      if ([command.x, command.y].every(Number.isFinite)) {
+        current = { x: command.x, y: command.y };
+        points.push(current);
+      }
+      continue;
+    }
+    if (command.op !== "C" || current === undefined) continue;
+    if (![command.x1, command.y1, command.x2, command.y2, command.x, command.y]
+      .every(Number.isFinite)) continue;
+    const roots = new Set([
+      0,
+      1,
+      ...cubicExtrema(current.x, command.x1, command.x2, command.x),
+      ...cubicExtrema(current.y, command.y1, command.y2, command.y)
+    ]);
+    for (const t of roots) {
+      points.push({
+        x: cubicValue(current.x, command.x1, command.x2, command.x, t),
+        y: cubicValue(current.y, command.y1, command.y2, command.y, t)
+      });
+    }
+    current = { x: command.x, y: command.y };
+  }
+  return points;
+}
+
 function primitiveBounds(type, properties = {}) {
   const strokeExtent = (properties.strokeWidth ?? 0) / 2;
   if (type === "circle") {
@@ -86,15 +149,7 @@ function primitiveBounds(type, properties = {}) {
   if (type === "path") {
     const commands = properties.commands;
     if (!Array.isArray(commands)) return undefined;
-    const points = commands.flatMap(command => {
-      if (command.op === "M" || command.op === "L") return [{ x: command.x, y: command.y }];
-      if (command.op === "C") return [
-        { x: command.x1, y: command.y1 },
-        { x: command.x2, y: command.y2 },
-        { x: command.x, y: command.y }
-      ];
-      return [];
-    }).filter(point => Number.isFinite(point.x) && Number.isFinite(point.y));
+    const points = pathPoints(commands);
     if (points.length === 0) return undefined;
     return {
       left: Math.min(...points.map(point => point.x)) - strokeExtent,

package/src/grammar/schemas/graphicTree.js

@@ -70,7 +70,7 @@ export function graphicSiblings(graphicSpec, target) {
   return graphicSpec.order;
 }
 
-function visitNamed(graphicSpec, id, visitor, path, visited) {
+function visitNamed(graphicSpec, id, visitors, path, visited) {
   if (path.includes(id)) {
     throw new Error(`Graphic attachment cycle includes "${id}".`);
   }
@@ -82,29 +82,37 @@ function visitNamed(graphicSpec, id, visitor, path, visited) {
     throw new Error(`Graphic "${id}" is attached more than once.`);
   }
   visited.add(id);
-  visitor({ id, object, kind: "object", depth: path.length });
+  const entry = { id, object, kind: "object", depth: path.length };
+  visitors.enter?.(entry);
   for (const item of object.items ?? []) {
-    visitor({
+    visitors.item?.({
       id: item.id,
       object: item,
       kind: "item",
       ownerId: id,
+      owner: object,
       depth: path.length + 1
     });
   }
   for (const childId of object.children ?? []) {
-    visitNamed(graphicSpec, childId, visitor, [...path, id], visited);
+    visitNamed(graphicSpec, childId, visitors, [...path, id], visited);
   }
+  visitors.exit?.(entry);
 }
 
-export function walkGraphicTree(graphicSpec, visitor) {
+export function walkGraphicTreeEvents(graphicSpec, visitors) {
   requireGraphicSpec(graphicSpec);
-  if (typeof visitor !== "function") {
-    throw new TypeError("walkGraphicTree requires a visitor function.");
+  if (!isPlainObject(visitors)) {
+    throw new TypeError("walkGraphicTreeEvents requires visitor callbacks.");
+  }
+  for (const name of ["enter", "item", "exit"]) {
+    if (visitors[name] !== undefined && typeof visitors[name] !== "function") {
+      throw new TypeError(`walkGraphicTreeEvents ${name} must be a function.`);
+    }
   }
   const visited = new Set();
   for (const id of graphicSpec.order) {
-    visitNamed(graphicSpec, id, visitor, [], visited);
+    visitNamed(graphicSpec, id, visitors, [], visited);
   }
   const orphan = Object.keys(graphicSpec.objects).find(id => !visited.has(id));
   if (orphan !== undefined) {
@@ -112,12 +120,38 @@ export function walkGraphicTree(graphicSpec, visitor) {
   }
 }
 
+export function walkGraphicTree(graphicSpec, visitor) {
+  if (typeof visitor !== "function") {
+    throw new TypeError("walkGraphicTree requires a visitor function.");
+  }
+  walkGraphicTreeEvents(graphicSpec, {
+    enter: visitor,
+    item: visitor
+  });
+}
+
 export function walkGraphicDrawOrder(graphicSpec, visitor) {
-  walkGraphicTree(graphicSpec, entry => {
-    if (entry.kind === "object") visitor(entry);
+  walkGraphicTreeEvents(graphicSpec, { enter: visitor });
+}
+
+export function findOrderedGraphicsByType(graphicSpec, type) {
+  requireGraphicSpec(graphicSpec);
+  return graphicSpec.order.flatMap(id => {
+    const object = graphicSpec.objects[id];
+    return object?.type === type ? [{ id, object }] : [];
   });
 }
 
+export function requireSingleOrderedGraphicByType(graphicSpec, type) {
+  const matches = findOrderedGraphicsByType(graphicSpec, type);
+  if (matches.length !== 1) {
+    throw new Error(
+      `graphicSpec must contain exactly one ordered ${type}.`
+    );
+  }
+  return matches[0];
+}
+
 export function collectGraphicSubtreeIds(graphicSpec, target) {
   const found = requireGraphic(graphicSpec, target);
   if (found.kind === "item") {

package/src/grammar/schemas/semanticPath.js

@@ -1,7 +1,7 @@
 import { USER_ID_SOURCE } from "../../core/identifiers.js";
 import {
+  CARTESIAN_POSITION_CHANNELS,
   ENCODING_CHANNELS,
-  POSITION_CHANNELS,
   SCALED_ENCODING_CHANNELS
 } from "../../core/vocabulary.js";
 
@@ -20,7 +20,9 @@ const ENCODING_PATHS = Object.freeze([
   "encoding.x.bin.boundaries",
   "encoding.color.layout",
   "encoding.color.aggregate",
-  ...POSITION_CHANNELS.flatMap(channel => [
+  "encoding.theta.aggregate",
+  "encoding.text.format",
+  ...CARTESIAN_POSITION_CHANNELS.flatMap(channel => [
     `encoding.${channel}.aggregate`,
     `encoding.${channel}.stack`
   ])
@@ -38,6 +40,7 @@ const ENTITY_PATHS = Object.freeze({
     ),
     properties: new Set([
       "data",
+      "source",
       "coordinate",
       "transform",
       "mark.type",
@@ -65,6 +68,12 @@ const GUIDE_PATHS = new Set([
   "axis.y.scale",
   "axis.y.coordinate",
   "axis.y.title",
+  "axis.theta.scale",
+  "axis.theta.coordinate",
+  "axis.theta.title",
+  "axis.radius.scale",
+  "axis.radius.coordinate",
+  "axis.radius.title",
   "legend.color.scale",
   "legend.color.title",
   "legend.size.scale",
@@ -77,10 +86,22 @@ const GUIDE_PATHS = new Set([
   "grid.horizontal.scale",
   "grid.horizontal.coordinate",
   "grid.vertical.scale",
-  "grid.vertical.coordinate"
+  "grid.vertical.coordinate",
+  "grid.theta.scale",
+  "grid.theta.coordinate",
+  "grid.radial.scale",
+  "grid.radial.coordinate"
 ]);
 
 const GUIDE_REMOVABLE_CONTAINERS = new Set([
+  "axis.x",
+  "axis.y",
+  "axis.theta",
+  "axis.radius",
+  "grid.horizontal",
+  "grid.vertical",
+  "grid.theta",
+  "grid.radial",
   "legend.color",
   "legend.size",
   "legend.opacity",
@@ -99,14 +120,15 @@ export function parseSemanticPath(property, { allowContainer = false } = {}) {
   }
 
   if (allowContainer) {
-    const datasetMatch = property.match(
-      new RegExp(`^dataset\\[(${USER_ID_SOURCE})\\]$`)
+    const entityMatch = property.match(
+      new RegExp(`^(dataset|layer)\\[(${USER_ID_SOURCE})\\]$`)
     );
-    if (datasetMatch) {
+    if (entityMatch) {
+      const [, kind, id] = entityMatch;
       return Object.freeze({
-        kind: "dataset",
-        id: datasetMatch[1],
-        collection: "datasets",
+        kind,
+        id,
+        collection: ENTITY_PATHS[kind].collection,
         path: Object.freeze([])
       });
     }

package/src/grammar/seriesLayout.js

@@ -1,6 +1,8 @@
 import { cloneAndFreeze } from "../core/immutable.js";
 import { COLOR_LAYOUTS } from "../core/vocabulary.js";
 
+export const DEFAULT_SERIES_BASELINE = 0;
+
 export function validateColorLayout(layout) {
   if (!COLOR_LAYOUTS.includes(layout)) {
     throw new Error(`Unsupported color layout "${layout}".`);
@@ -14,7 +16,11 @@ function validateValues(values) {
   }
 }
 
-export function layoutSeriesPartition(values, layout, { baseline = 0 } = {}) {
+export function layoutSeriesPartition(
+  values,
+  layout,
+  { baseline = DEFAULT_SERIES_BASELINE } = {}
+) {
   validateValues(values);
   validateColorLayout(layout);
   if (!Number.isFinite(baseline)) {
@@ -66,7 +72,12 @@ export function resolveSeriesLayoutDomainValues(partitions, layout) {
   for (const partition of partitions) validateValues(partition);
 
   if (layout === "fill") return [0, 1];
-  if (layout === "group" || layout === "overlay") return partitions.flat();
+  if (layout === "group" || layout === "overlay") {
+    return partitions.flatMap(partition => [
+      DEFAULT_SERIES_BASELINE,
+      ...partition
+    ]);
+  }
   return partitions.flatMap(partition =>
     layoutSeriesPartition(partition, layout).flatMap(segment => [
       segment.start,

package/src/grammar/statistics/studentT.js

@@ -0,0 +1,98 @@
+const LANCZOS = Object.freeze([
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9.984369578019572e-6,
+  1.5056327351493116e-7
+]);
+
+function logGamma(value) {
+  if (value < 0.5) {
+    return Math.log(Math.PI) - Math.log(Math.sin(Math.PI * value)) -
+      logGamma(1 - value);
+  }
+  const shifted = value - 1;
+  let sum = 0.9999999999998099;
+  for (const [index, coefficient] of LANCZOS.entries()) {
+    sum += coefficient / (shifted + index + 1);
+  }
+  const base = shifted + LANCZOS.length - 0.5;
+  return 0.5 * Math.log(2 * Math.PI) +
+    (shifted + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+
+function betaContinuedFraction(a, b, value) {
+  const maximumIterations = 200;
+  const epsilon = 3e-14;
+  const floor = 1e-300;
+  const sum = a + b;
+  let c = 1;
+  let d = 1 - sum * value / (a + 1);
+  if (Math.abs(d) < floor) d = floor;
+  d = 1 / d;
+  let result = d;
+
+  for (let iteration = 1; iteration <= maximumIterations; iteration += 1) {
+    const even = 2 * iteration;
+    let coefficient = iteration * (b - iteration) * value /
+      ((a + even - 1) * (a + even));
+    d = 1 + coefficient * d;
+    if (Math.abs(d) < floor) d = floor;
+    c = 1 + coefficient / c;
+    if (Math.abs(c) < floor) c = floor;
+    d = 1 / d;
+    result *= d * c;
+
+    coefficient = -(a + iteration) * (sum + iteration) * value /
+      ((a + even) * (a + even + 1));
+    d = 1 + coefficient * d;
+    if (Math.abs(d) < floor) d = floor;
+    c = 1 + coefficient / c;
+    if (Math.abs(c) < floor) c = floor;
+    d = 1 / d;
+    const delta = d * c;
+    result *= delta;
+    if (Math.abs(delta - 1) <= epsilon) return result;
+  }
+  throw new Error("Student-t calculation did not converge.");
+}
+
+function regularizedIncompleteBeta(value, a, b) {
+  if (value === 0 || value === 1) return value;
+  const factor = Math.exp(
+    logGamma(a + b) - logGamma(a) - logGamma(b) +
+    a * Math.log(value) + b * Math.log1p(-value)
+  );
+  if (value < (a + 1) / (a + b + 2)) {
+    return factor * betaContinuedFraction(a, b, value) / a;
+  }
+  return 1 - factor * betaContinuedFraction(b, a, 1 - value) / b;
+}
+
+function studentTCdf(value, degreesOfFreedom) {
+  if (value === 0) return 0.5;
+  const ratio = degreesOfFreedom /
+    (degreesOfFreedom + value * value);
+  const tail = regularizedIncompleteBeta(
+    ratio,
+    degreesOfFreedom / 2,
+    0.5
+  ) / 2;
+  return value > 0 ? 1 - tail : tail;
+}
+
+export function studentTCriticalValue(level, degreesOfFreedom) {
+  const probability = (1 + level) / 2;
+  let low = 0;
+  let high = 1;
+  while (studentTCdf(high, degreesOfFreedom) < probability) high *= 2;
+  for (let iteration = 0; iteration < 100; iteration += 1) {
+    const midpoint = (low + high) / 2;
+    if (studentTCdf(midpoint, degreesOfFreedom) < probability) low = midpoint;
+    else high = midpoint;
+  }
+  return (low + high) / 2;
+}

package/src/grammar/text.js

@@ -0,0 +1,71 @@
+import { cloneAndFreeze } from "../core/immutable.js";
+import { validateConcreteGraphicValue } from "./schemas/concreteGraphic.js";
+
+export const DEFAULT_TEXT_MARK = cloneAndFreeze({
+  fill: "#334155",
+  opacity: 1,
+  fontSize: 12,
+  fontFamily: "sans-serif",
+  fontWeight: "normal",
+  align: "left",
+  baseline: "alphabetic",
+  rotation: 0,
+  dx: 0,
+  dy: 0
+});
+
+const FIXED_FORMAT = /^\.(\d{1,2})f$/;
+
+export function validateTextFormat(format) {
+  if (format === undefined || format === "auto") return format ?? "auto";
+  if (typeof format !== "string" || !FIXED_FORMAT.test(format)) {
+    throw new Error(
+      'Text format must be "auto" or a fixed-decimal token such as ".1f".'
+    );
+  }
+  const decimals = Number(format.match(FIXED_FORMAT)[1]);
+  if (decimals > 12) {
+    throw new RangeError("Text fixed-decimal format supports at most 12 decimals.");
+  }
+  return format;
+}
+
+export function formatTextValue(value, format = "auto") {
+  const resolved = validateTextFormat(format);
+  if (value === undefined || value === null) return undefined;
+  if (resolved === "auto") {
+    const text = String(value);
+    return text.length === 0 ? undefined : text;
+  }
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`Text format "${resolved}" requires a finite number.`);
+  }
+  return value.toFixed(Number(resolved.match(FIXED_FORMAT)[1]));
+}
+
+export function normalizeTextMarkConfig(options, base = DEFAULT_TEXT_MARK) {
+  const config = { ...base };
+  const mapping = {
+    fill: "fill",
+    opacity: "opacity",
+    fontSize: "fontSize",
+    fontFamily: "fontFamily",
+    fontWeight: "fontWeight",
+    align: "textAlign",
+    baseline: "textBaseline",
+    rotation: "rotation"
+  };
+  for (const [option, property] of Object.entries(mapping)) {
+    if (!Object.hasOwn(options, option)) continue;
+    validateConcreteGraphicValue("text", property, options[option]);
+    config[option] = options[option];
+  }
+  for (const property of ["dx", "dy"]) {
+    if (!Object.hasOwn(options, property)) continue;
+    if (!Number.isFinite(options[property])) {
+      throw new TypeError(`Text ${property} must be a finite number.`);
+    }
+    config[property] = options[property];
+  }
+  return cloneAndFreeze(config);
+}