ggaction 0.0.17 → 0.0.19

package/src/grammar/regression/parameters.js

@@ -45,14 +45,23 @@ export function normalizeRegressionParameters({
   method = "linear",
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   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.");
@@ -69,7 +78,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 +157,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 +183,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 +220,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/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/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
         })
       });

package/src/grammar/scales/appearance.js

@@ -1,206 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
-import { validateUnitInterval } from "../../core/validation.js";
-import { POINT_SHAPES } from "../pointShapes.js";
-import {
-  normalizePalette,
-  resolvePalette
-} from "../palettes.js";
-
-export const DASH10 = cloneAndFreeze([
-  [], [8, 4], [3, 3], [12, 4], [8, 3, 2, 3],
-  [12, 3, 3, 3], [2, 2], [10, 3, 2, 3, 2, 3], [14, 4, 4, 4], [6, 2, 2, 2]
-]);
-export const NAMED_DASH_PATTERNS = cloneAndFreeze({
-  solid: [],
-  dashed: [6, 4],
-  dotted: [1, 3],
-  dashdot: [6, 3, 1, 3]
-});
-
-export { POINT_SHAPES } from "../pointShapes.js";
-export const DEFAULT_SIZE_RANGE = cloneAndFreeze([24, 196]);
-export const DEFAULT_OPACITY_RANGE = cloneAndFreeze([0.2, 1]);
-export const DEFAULT_STROKE_WIDTH_RANGE = cloneAndFreeze([1, 8]);
-
-export function validateColorRange(range) {
-  if (range === "auto") return range;
-  if (Array.isArray(range)) {
-    if (
-      range.length === 0 ||
-      !range.every(color => typeof color === "string" && color.length > 0)
-    ) {
-      throw new TypeError("Color range must contain non-empty color strings.");
-    }
-    return cloneAndFreeze(range);
-  }
-  if (
-    !isPlainObject(range) ||
-    Object.keys(range).length !== 1 ||
-    !Object.hasOwn(range, "palette")
-  ) {
-    throw new Error("Color range must contain only a palette descriptor.");
-  }
-  normalizePalette(range.palette);
-  return cloneAndFreeze(range);
-}
-
-function isDashPattern(pattern) {
-  return (
-    Array.isArray(pattern) &&
-    pattern.length % 2 === 0 &&
-    pattern.every(value => Number.isFinite(value) && value >= 0) &&
-    (pattern.length === 0 || pattern.some(value => value > 0))
-  );
-}
-
-export function normalizeStrokeDashPattern(pattern) {
-  if (typeof pattern === "string") {
-    const resolved = NAMED_DASH_PATTERNS[pattern];
-    if (resolved === undefined) {
-      throw new Error(`Unknown stroke dash style "${pattern}".`);
-    }
-    return cloneAndFreeze(resolved);
-  }
-  if (!isDashPattern(pattern)) {
-    throw new TypeError(
-      "Stroke dash pattern must be a named style or an empty or nonzero even-length array of non-negative finite numbers."
-    );
-  }
-  return cloneAndFreeze(pattern);
-}
-
-export function validateStrokeDashRange(range) {
-  if (range === "auto") return range;
-  if (!Array.isArray(range) || range.length === 0) {
-    throw new TypeError(
-      "StrokeDash range must contain one or more named styles or direct patterns."
-    );
-  }
-  for (const pattern of range) normalizeStrokeDashPattern(pattern);
-  return cloneAndFreeze(range);
-}
-
-export function validateShapeRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length === 0 ||
-    !range.every(shape => POINT_SHAPES.includes(shape)) ||
-    new Set(range).size !== range.length
-  ) {
-    throw new TypeError(
-      "Shape range must contain unique supported point shapes."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateSizeRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0) ||
-    range[0] > range[1]
-  ) {
-    throw new TypeError(
-      "Size range must be an ascending pair of non-negative finite areas."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateOpacityRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0 && value <= 1)
-  ) {
-    throw new TypeError(
-      "Opacity range must contain two finite values from 0 to 1."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateStrokeWidthRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0) ||
-    range[0] > range[1]
-  ) {
-    throw new TypeError(
-      "StrokeWidth range must be an ascending pair of non-negative finite widths."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateOpacityValue(value, label = "Opacity") {
-  return validateUnitInterval(value, label);
-}
-
-export function validateSemanticScaleRange(range) {
-  if (range === "auto") return range;
-  if (Array.isArray(range) && range.length > 0) return cloneAndFreeze(range);
-  if (isPlainObject(range) && Object.hasOwn(range, "palette")) {
-    normalizePalette(range.palette);
-    return cloneAndFreeze(range);
-  }
-  throw new TypeError("Scale range has an unsupported value.");
-}
-
-export function resolveColorRange(range, domainCount) {
-  const validated = validateColorRange(range);
-  if (validated === "auto") return TABLEAU10;
-  if (Array.isArray(validated)) return validated;
-  return resolvePalette(validated.palette, domainCount);
-}
-
-export function resolveStrokeDashRange(range) {
-  const validated = validateStrokeDashRange(range);
-  return validated === "auto"
-    ? DASH10
-    : cloneAndFreeze(validated.map(normalizeStrokeDashPattern));
-}
-
-export function resolveShapeRange(range) {
-  const validated = validateShapeRange(range);
-  return validated === "auto" ? POINT_SHAPES : validated;
-}
-
-export function resolveSizeRange(range) {
-  const validated = validateSizeRange(range);
-  return validated === "auto" ? DEFAULT_SIZE_RANGE : validated;
-}
-
-export function resolveOpacityRange(range) {
-  const validated = validateOpacityRange(range);
-  return validated === "auto" ? DEFAULT_OPACITY_RANGE : validated;
-}
-
-export function resolveStrokeWidthRange(range) {
-  const validated = validateStrokeWidthRange(range);
-  return validated === "auto" ? DEFAULT_STROKE_WIDTH_RANGE : validated;
-}
-
-export function mapOrdinalValues(values, domain, range, options = {}) {
-  const hasUnknown = Object.hasOwn(options, "unknown");
-  const indices = new Map(domain.map((value, index) => [value, index]));
-  return cloneAndFreeze(values.map(value => {
-    const index = indices.get(value);
-    if (index === undefined) {
-      if (hasUnknown) return options.unknown;
-      throw new Error(`Value "${value}" is outside the ordinal domain.`);
-    }
-    return range[index % range.length];
-  }));
-}
-
-export const TABLEAU10 = resolvePalette(
-  { name: "tableau10", count: 10 },
-  10
-);
+import{cloneAndFreeze as r,isPlainObject as s}from"../../core/immutable.js";import{validateUnitInterval as y}from"../../core/validation.js";import{POINT_SHAPES as u}from"../pointShapes.js";import{normalizePalette as c,resolvePalette as l}from"../palettes.js";const m=r([[],[8,4],[3,3],[12,4],[8,3,2,3],[12,3,3,3],[2,2],[10,3,2,3,2,3],[14,4,4,4],[6,2,2,2]]),A=r({solid:[],dashed:[6,4],dotted:[1,3],dashdot:[6,3,1,3]});import{POINT_SHAPES as g}from"../pointShapes.js";const v=r([24,196]),w=r([.2,1]),S=r([1,8]);function x(t){if(t==="auto")return t;if(Array.isArray(t)){if(t.length===0||!t.every(e=>typeof e=="string"&&e.length>0))throw new TypeError("Color range must contain non-empty color strings.");return r(t)}if(!s(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new Error("Color range must contain only a palette descriptor.");return c(t.palette),r(t)}function E(t){return Array.isArray(t)&&t.length%2===0&&t.every(e=>Number.isFinite(e)&&e>=0)&&(t.length===0||t.some(e=>e>0))}function p(t){if(typeof t=="string"){const e=A[t];if(e===void 0)throw new Error(`Unknown stroke dash style "${t}".`);return r(e)}if(!E(t))throw new TypeError("Stroke dash pattern must be a named style or an empty or nonzero even-length array of non-negative finite numbers.");return r(t)}function R(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length===0)throw new TypeError("StrokeDash range must contain one or more named styles or direct patterns.");for(const e of t)p(e);return r(t)}function O(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length===0||!t.every(e=>u.includes(e)))throw new TypeError("Shape range must contain supported point shapes.");return r(t)}function f(t,e){if(t==="auto")return t;if(!Array.isArray(t)||t.length!==2||!t.every(o=>Number.isFinite(o)&&o>=0)||t[0]>t[1])throw new TypeError(`${e} must be an ascending pair of non-negative finite ${e==="Size range"?"areas":"widths"}.`);return r(t)}function T(t){return f(t,"Size range")}function k(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length!==2||!t.every(e=>Number.isFinite(e)&&e>=0&&e<=1))throw new TypeError("Opacity range must contain two finite values from 0 to 1.");return r(t)}function D(t){return f(t,"StrokeWidth range")}function F(t,e="Opacity"){return y(t,e)}function U(t){if(t==="auto")return t;if(Array.isArray(t)&&t.length>0)return r(t);if(s(t)&&Object.hasOwn(t,"palette"))return c(t.palette),r(t);throw new TypeError("Scale range has an unsupported value.")}function I(t,e){const o=x(t);return o==="auto"?b:Array.isArray(o)?o:l(o.palette,e)}function j(t){const e=R(t);return e==="auto"?m:r(e.map(p))}function C(t){const e=O(t);return e==="auto"?u:e}function H(t){const e=T(t);return e==="auto"?v:e}function L(t){const e=k(t);return e==="auto"?w:e}function W(t){const e=D(t);return e==="auto"?S:e}function $(t,e,o,a={}){const d=Object.hasOwn(a,"unknown"),h=new Map(e.map((n,i)=>[n,i]));return r(t.map(n=>{const i=h.get(n);if(i===void 0){if(d)return a.unknown;throw new Error(`Value "${n}" is outside the ordinal domain.`)}return o[i%o.length]}))}const b=l({name:"tableau10",count:10},10);export{m as DASH10,w as DEFAULT_OPACITY_RANGE,v as DEFAULT_SIZE_RANGE,S as DEFAULT_STROKE_WIDTH_RANGE,A as NAMED_DASH_PATTERNS,g as POINT_SHAPES,b as TABLEAU10,$ as mapOrdinalValues,p as normalizeStrokeDashPattern,I as resolveColorRange,L as resolveOpacityRange,C as resolveShapeRange,H as resolveSizeRange,j as resolveStrokeDashRange,W as resolveStrokeWidthRange,x as validateColorRange,k as validateOpacityRange,F as validateOpacityValue,U as validateSemanticScaleRange,O as validateShapeRange,T as validateSizeRange,R as validateStrokeDashRange,D as validateStrokeWidthRange};