ggaction 0.0.17 → 0.0.19

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

@@ -0,0 +1,27 @@
+import { validateOptionObject, validatePositiveFinite, validateUnitInterval } from "../core/validation.js";
+
+export const DEFAULT_LEGEND_GRADIENT = Object.freeze({ length: 120, thickness: 12 });
+const OPTIONS = Object.freeze(["length", "thickness", "opacity"]);
+
+export function validateLegendGradient(value, label = "Legend gradient") {
+  validateOptionObject(value, OPTIONS, label);
+  validatePositiveFinite(value.length, `${label} length`);
+  validatePositiveFinite(value.thickness, `${label} thickness`);
+  if (Object.hasOwn(value, "opacity")) validateUnitInterval(value.opacity, `${label} opacity`);
+}
+
+export function normalizeLegendGradient(patch, previous = DEFAULT_LEGEND_GRADIENT) {
+  if (patch !== undefined) validateOptionObject(patch, OPTIONS, "Legend gradient");
+  const value = { ...previous, ...patch };
+  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

@@ -0,0 +1 @@
+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/legendTitleStyle.js

@@ -0,0 +1,22 @@
+import { validateOptionObject } from "../core/validation.js";
+
+export const LEGEND_TITLE_STYLE_KEYS = Object.freeze([
+  "color", "fontSize", "fontFamily", "fontWeight", "align"
+]);
+
+export function validateLegendTitleAlignment(style, titlePosition = "top") {
+  if (style?.align === undefined) {
+    if (style !== undefined && Object.hasOwn(style, "align")) throw new TypeError("Legend title align requires left, center or right.");
+    return;
+  }
+  if (!["left", "center", "right"].includes(style.align)) throw new Error("Legend title align requires left, center or right.");
+  if (titlePosition === "left") throw new Error("Inline legend titles do not accept title alignment.");
+}
+
+export function mergeLegendTitleStyle(previous, patch, { edit = false } = {}) {
+  if (patch !== undefined) validateOptionObject(patch, LEGEND_TITLE_STYLE_KEYS, "Legend titleStyle");
+  const result = { ...previous, ...patch };
+  if (edit && patch?.align === "auto") delete result.align;
+  validateLegendTitleAlignment(result);
+  return result;
+}

package/src/grammar/lineSeries.js

@@ -29,7 +29,7 @@ function requireLineEncoding(layer) {
   const y = layer.encoding?.y;
 
   if (x === undefined) {
-    throw new Error(`Line mark "${layer.id}" requires a temporal x encoding.`);
+    throw new Error(`Line mark "${layer.id}" requires an x encoding.`);
   }
 
   const binnedAggregate =
@@ -37,10 +37,10 @@ function requireLineEncoding(layer) {
     x.bin !== undefined &&
     isAggregate(y?.aggregate);
   const aggregateMode =
-    (x?.fieldType === "temporal" && isAggregate(y?.aggregate)) ||
+    (["temporal", "nominal", "ordinal"].includes(x?.fieldType) && isAggregate(y?.aggregate)) ||
     binnedAggregate;
-  const directQuantitative =
-    x?.fieldType === "quantitative" &&
+  const directNumericY =
+    ["quantitative", "nominal", "ordinal"].includes(x?.fieldType) &&
     x.bin === undefined &&
     y?.fieldType === "quantitative" &&
     y.aggregate === undefined;
@@ -48,14 +48,14 @@ function requireLineEncoding(layer) {
     y?.aggregate === undefined &&
     ((x?.fieldType === "temporal" && y?.fieldType === "quantitative") ||
       (x?.fieldType === "quantitative" && y?.fieldType === "temporal"));
-  if (!aggregateMode && !directQuantitative && !directTemporal) {
+  if (!aggregateMode && !directNumericY && !directTemporal) {
     if (x?.fieldType === "temporal") {
       throw new Error(
         `Line mark "${layer.id}" requires a supported aggregate y encoding.`
       );
     }
     throw new Error(
-      `Line mark "${layer.id}" requires temporal/aggregate or direct quantitative x/y encodings.`
+      `Line mark "${layer.id}" requires categorical/temporal aggregate or compatible direct x/y encodings.`
     );
   }
   if (aggregateMode) {
@@ -66,7 +66,7 @@ function requireLineEncoding(layer) {
     y,
     isAggregate: aggregateMode,
     binnedAggregate,
-    directRows: directTemporal || directQuantitative,
+    directRows: directTemporal || directNumericY,
     directTemporal
   };
 }
@@ -90,9 +90,17 @@ function groupedSeries(groups, fields, dimensions) {
   return series;
 }
 
-function freezeCartesianSeries(series) {
+function freezeCartesianSeries(series, categoryOrder) {
+  const observedX = series.flatMap(item => item.values.map(value => value.x));
+  const observedSet = new Set(observedX);
+  if (categoryOrder !== undefined) {
+    const domain = new Set(categoryOrder);
+    if (observedX.some(value => !domain.has(value))) {
+      throw new Error("Line categorical x domain must contain every observed vertex.");
+    }
+  }
   return cloneAndFreeze({
-    xValues: series.flatMap(item => item.values.map(value => value.x)),
+    xValues: categoryOrder === undefined ? observedX : categoryOrder.filter(value => observedSet.has(value)),
     yValues: series.flatMap(item => item.values.map(value => value.y)),
     series
   });
@@ -122,7 +130,9 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   if (isAggregate) {
     validateAggregateFieldValues(rows, y.field, y.fieldType);
   }
-  const xValues = x.fieldType === "temporal"
+  const categorical = ["nominal", "ordinal"].includes(x.fieldType);
+  const xValues = categorical ? readNominalField(rows, x.field)
+    : x.fieldType === "temporal"
     ? readTemporalField(rows, x.field, x.temporalUnit)
     : readQuantitativeField(rows, x.field);
   const yValues = isAggregate
@@ -130,6 +140,11 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     : y.fieldType === "temporal"
       ? readTemporalField(rows, y.field, y.temporalUnit)
       : readQuantitativeField(rows, y.field);
+  const categoryOrder = categorical ? options.xDomain ?? [...new Set(xValues)] : undefined;
+  const ranks = new Map(categoryOrder?.map((value, index) => [value, index]));
+  const compareX = categorical
+    ? (left, right) => ranks.get(left.x) - ranks.get(right.x)
+    : (left, right) => left.x - right.x;
   const seriesFields = validatePathSeriesAppearance(rows, layer);
   const binBoundaries = binnedAggregate
     ? options.xBinBoundaries ?? resolveLineBins(rows, layer).boundaries
@@ -159,14 +174,14 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
         item.orderValues,
         pathOrder.order
       );
-      return values.length < 2 ? [] : [{ key: item.key, values }];
+      return [{ key: item.key, values }];
     });
     if (series.length === 0) {
       throw new Error(
         `Line series on mark "${layer.id}" requires at least two ordered points.`
       );
     }
-    return freezeCartesianSeries(series);
+    return freezeCartesianSeries(series, categoryOrder);
   }
 
   if (directRows) {
@@ -181,16 +196,16 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     const orderBy = directTemporal && y.fieldType === "temporal" ? "y" : "x";
     const series = [...groups.values()].flatMap(item => {
       const values = item.values.sort(
-        (left, right) => left[orderBy] - right[orderBy]
+        orderBy === "x" ? compareX : (left, right) => left.y - right.y
       );
-      return values.length < 2 ? [] : [{ key: item.key, values }];
+      return [{ key: item.key, values }];
     });
     if (series.length === 0) {
       throw new Error(
         `Line series on mark "${layer.id}" requires at least two direct points.`
       );
     }
-    return freezeCartesianSeries(series);
+    return freezeCartesianSeries(series, categoryOrder);
   }
   const aggregateGroups = new Map();
 
@@ -241,7 +256,7 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   }
 
   const series = [...seriesGroups.values()].flatMap(item => {
-    const values = item.values.sort((left, right) => left.x - right.x);
+    const values = item.values.sort(compareX);
 
     if (values.length < 2) {
       return [];
@@ -256,7 +271,7 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     );
   }
 
-  return freezeCartesianSeries(series);
+  return freezeCartesianSeries(series, categoryOrder);
 }
 
 function requirePolarLineEncoding(layer) {

package/src/grammar/markLabels.js

@@ -35,7 +35,8 @@ export function normalizeMarkLabelContent(source, { content, normalizeBy }) {
   }
   if (source.mark.type === "bar") {
     const grain = resolveBarGrain(source);
-    if (grain === BAR_GRAINS.ranged) {
+    if (grain === BAR_GRAINS.ranged || grain === BAR_GRAINS.centered &&
+        source.encoding[`${resolveBarChannels(source).measure}2`] !== undefined) {
       throw new Error("Ranged Bar text requires an explicit field or value.");
     }
     if (content === "category" && grain === BAR_GRAINS.histogram) {
@@ -63,10 +64,12 @@ function itemValue(source, item) {
       );
     }
     const measure = source.encoding[resolveBarChannels(source).measure];
+    if (resolveBarGrain(source) === BAR_GRAINS.centered) return item.channels[`${resolveBarChannels(source).measure}2`];
     return measure.aggregate === "count" ? item.members.length
       : aggregateRows(item.members, measure.field, measure.aggregate);
   }
-  if (source.encoding?.radius !== undefined) return item.channels.radius;
+  if (source.encoding?.radius !== undefined && source.encoding.theta.fieldType !== "quantitative" &&
+      source.encoding.theta.aggregate === undefined) return item.channels.radius;
   const theta = source.encoding.theta;
   if (theta.fieldType === "quantitative") return item.channels.theta;
   return theta.aggregate === "count" ? item.members.length

package/src/grammar/normalize.js

@@ -1,3 +1,6 @@
+import { scalarKey, normalizeSortBy, validateSortBy } from "./transformKeys.js";
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import {
   inverseLerp,
@@ -15,23 +18,9 @@ const METHODS = Object.freeze([
   "share", "zscore", "minmax", "index", "change", "percentChange"
 ]);
 const ZERO_POLICIES = Object.freeze(["error", "null", "zero"]);
-const SORT_KEYS = Object.freeze(["field", "order"]);
-const ORDERS = Object.freeze(["ascending", "descending"]);
 const BASELINE_KEYS = Object.freeze(["position", "value"]);
 const BASELINE_METHODS = new Set(["index", "change", "percentChange"]);
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
-}
-
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function normalizeGroupBy(value) {
   if (value === undefined) return [];
   return Array.isArray(value) ? [...value] : [value];
@@ -48,33 +37,6 @@ function validateGroupBy(groupBy) {
   }
 }
 
-function normalizeSortBy(value) {
-  if (value === undefined) return [];
-  if (!Array.isArray(value)) return value;
-  return value.map(sort => isPlainObject(sort)
-    ? { ...sort, order: sort.order ?? "ascending" }
-    : sort
-  );
-}
-
-function validateSortBy(sortBy) {
-  if (!Array.isArray(sortBy)) throw new TypeError("Normalize sortBy must be an array.");
-  const fields = [];
-  sortBy.forEach((sort, index) => {
-    if (!isPlainObject(sort)) {
-      throw new TypeError(`Normalize sortBy[${index}] must be a plain object.`);
-    }
-    rejectUnknownKeys(sort, SORT_KEYS, `normalize sortBy[${index}]`);
-    fields.push(requireField(sort.field, `Normalize sortBy[${index}].field`));
-    if (!ORDERS.includes(sort.order)) {
-      throw new Error(`Unsupported normalize sort order "${sort.order}".`);
-    }
-  });
-  if (new Set(fields).size !== fields.length) {
-    throw new Error("Normalize sortBy fields must be unique.");
-  }
-}
-
 function normalizeBaseline(value) {
   if (!isPlainObject(value)) return value;
   return { ...value };
@@ -136,7 +98,7 @@ export function validateNormalizeTransform(transform) {
     throw new Error("Normalize zeroDenominator is not available for change.");
   }
   if (BASELINE_METHODS.has(transform.method)) {
-    validateSortBy(transform.sortBy);
+    validateSortBy(transform.sortBy, "Normalize");
     validateBaseline(transform.baseline, transform.sortBy);
   } else {
     if (hasBaseline) {
@@ -184,18 +146,6 @@ export function normalizeNormalizeTransform(args = {}) {
   return cloneAndFreeze(transform);
 }
 
-function scalarKey(value, label) {
-  if (value === null) return "null";
-  if (typeof value === "string") return `string:${value.length}:${value}`;
-  if (typeof value === "boolean") return `boolean:${value}`;
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return `number:${Object.is(value, -0) ? 0 : value}`;
-  }
-  throw new TypeError(
-    `${label} must contain null, strings, booleans, or finite numbers.`
-  );
-}
-
 function compareScalar(left, right, label) {
   const leftMissing = left === null || left === undefined;
   const rightMissing = right === null || right === undefined;

package/src/grammar/numeric.js

@@ -1,290 +1 @@
-export const NICE_FACTORS = Object.freeze([1, 2, 3, 5]);
-
-function finiteArray(values, label) {
-  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
-    throw new TypeError(`${label} must contain finite numbers.`);
-  }
-}
-
-function rangeError(label) {
-  return new RangeError(`${label} is outside the finite numeric range.`);
-}
-
-function compensatedSum(values, scale = 1) {
-  let total = 0;
-  let correction = 0;
-  for (const source of values) {
-    const value = source / scale;
-    const next = total + value;
-    correction += Math.abs(total) >= Math.abs(value)
-      ? total - next + value
-      : value - next + total;
-    total = next;
-  }
-  return total + correction;
-}
-
-export function maximumMagnitude(values) {
-  let maximum = 0;
-  for (const value of values) maximum = Math.max(maximum, Math.abs(value));
-  return maximum;
-}
-
-export function normalizedFiniteSum(values, label = "Numeric values") {
-  finiteArray(values, label);
-  const scale = maximumMagnitude(values) || 1;
-  return { scale, total: compensatedSum(values, scale) };
-}
-
-export function requireFiniteResult(value, label = "Numeric result") {
-  if (!Number.isFinite(value)) throw rangeError(label);
-  return value === 0 ? 0 : value;
-}
-
-export function restoreFiniteScale(value, scale, label = "Numeric result") {
-  if (!Number.isFinite(value) || !Number.isFinite(scale) || scale < 0) {
-    throw rangeError(label);
-  }
-  return requireFiniteResult(value * scale, label);
-}
-
-function stableReducedSum(values, label, divisor = 1) {
-  finiteArray(values, label);
-  const ordinary = values.reduce((sum, value) => sum + value, 0);
-  if (Number.isFinite(ordinary)) {
-    return ordinary === 0 ? 0 : ordinary / divisor;
-  }
-  const scale = maximumMagnitude(values) || 1;
-  return restoreFiniteScale(
-    compensatedSum(values, scale) / divisor, scale, label
-  );
-}
-
-export function stableFiniteSum(values, label = "Numeric sum") {
-  return stableReducedSum(values, label);
-}
-
-export function stableFinitePrefixSums(values, label = "Numeric sum") {
-  const normalized = normalizedFiniteSum(values, label);
-  let ordinary = 0;
-  let sum = 0;
-  let correction = 0;
-  return values.map(value => {
-    ordinary += value;
-    const scaled = value / normalized.scale;
-    const next = sum + scaled;
-    correction += Math.abs(sum) >= Math.abs(scaled)
-      ? sum - next + scaled
-      : scaled - next + sum;
-    sum = next;
-    return Number.isFinite(ordinary)
-      ? ordinary === 0 ? 0 : ordinary
-      : restoreFiniteScale(sum + correction, normalized.scale, label);
-  });
-}
-
-export function stableFiniteMean(values, label = "Numeric mean") {
-  finiteArray(values, label);
-  if (values.length === 0) {
-    throw new RangeError(`${label} requires at least one value.`);
-  }
-  return stableReducedSum(values, label, values.length);
-}
-
-export function stableFiniteSquareSum(values, label = "Numeric square sum") {
-  finiteArray(values, label);
-  const ordinary = values.reduce((sum, value) => sum + value ** 2, 0);
-  if (Number.isFinite(ordinary)) return ordinary;
-  const scale = maximumMagnitude(values);
-  if (scale === 0) return 0;
-  const normalized = values.reduce(
-    (sum, value) => sum + (value / scale) ** 2,
-    0
-  );
-  const magnitude = restoreFiniteScale(Math.sqrt(normalized), scale, label);
-  return requireFiniteResult(magnitude ** 2, label);
-}
-
-export function stableFiniteDeviation(values, {
-  sample = false,
-  divisor = 1,
-  label = "Numeric deviation"
-} = {}) {
-  if (!Number.isFinite(divisor) || divisor <= 0) {
-    throw new RangeError(`${label} divisor must be positive and finite.`);
-  }
-  const denominator = values.length - (sample ? 1 : 0);
-  if (denominator <= 0) {
-    throw new RangeError(`${label} requires more values.`);
-  }
-  const mean = stableFiniteMean(values, `${label} mean`);
-  const differences = values.map(value => value - mean);
-  const squared = differences.reduce(
-    (sum, difference) => sum + difference ** 2,
-    0
-  );
-  if (Number.isFinite(squared)) {
-    return {
-      mean,
-      deviation: Math.sqrt(squared / denominator) / divisor,
-      squared
-    };
-  }
-  const finiteDifferences = differences.every(Number.isFinite);
-  const scale = finiteDifferences
-    ? maximumMagnitude(differences)
-    : Math.max(Math.abs(mean), maximumMagnitude(values));
-  if (scale === 0) return { mean, deviation: 0 };
-  const normalizedSquares = values.reduce((sum, value, index) => {
-    const difference = finiteDifferences
-      ? differences[index] / scale
-      : value / scale - mean / scale;
-    return sum + difference ** 2;
-  }, 0);
-  const deviation = restoreFiniteScale(
-    Math.sqrt(normalizedSquares / denominator) / divisor,
-    scale,
-    label
-  );
-  return { mean, deviation };
-}
-
-export function numericExtent(values) {
-  let minimum = Infinity;
-  let maximum = -Infinity;
-  for (const value of values) {
-    minimum = Math.min(minimum, value);
-    maximum = Math.max(maximum, value);
-  }
-  return [minimum, maximum];
-}
-
-export function normalizeNumericRange(start, end) {
-  const magnitude = Math.max(Math.abs(start), Math.abs(end));
-  if (magnitude === 0) {
-    return { scale: 1, start: 0, end: 0, span: 0 };
-  }
-
-  const decimalScale = 10 ** Math.floor(Math.log10(magnitude));
-  const scale = Number.isFinite(decimalScale) && decimalScale > 0
-    ? decimalScale
-    : magnitude;
-  start /= scale;
-  end /= scale;
-  return {
-    scale,
-    start,
-    end,
-    span: end - start
-  };
-}
-
-export function niceNumericStep(
-  span,
-  count = 5,
-  factors = NICE_FACTORS
-) {
-  if (!Number.isFinite(span) || span <= 0) {
-    throw new RangeError("Nice numeric span must be positive and finite.");
-  }
-  const rough = span / Math.max(1, count);
-  const power = 10 ** Math.floor(Math.log10(rough));
-  const fraction = rough / power;
-  const factor = factors.find(candidate => candidate >= fraction) ?? 10;
-  return factor * power;
-}
-
-export function alignNumericStep(value, step, direction) {
-  let quotient = value / step;
-  const nearest = Math.round(quotient);
-  if (Math.abs(quotient - nearest) <= 1e-10) quotient = nearest;
-  return (direction === "floor" ? Math.floor(quotient) : Math.ceil(quotient)) * step;
-}
-
-export function cleanNumericValue(value, resolution) {
-  if (!Number.isFinite(value) || value === 0) return value === 0 ? 0 : value;
-  const rounded = Number(value.toPrecision(15));
-  return Number.isFinite(resolution) && resolution > 0 &&
-    Math.abs(rounded - value) <= resolution * 1e-10
-    ? rounded
-    : value;
-}
-
-export function inverseLerp(value, start, end) {
-  if (value === start) return 0;
-  if (value === end) return 1;
-
-  const span = end - start;
-  const offset = value - start;
-  if (Number.isFinite(span) && span !== 0 && Number.isFinite(offset)) {
-    return offset / span;
-  }
-
-  const scale = Math.max(Math.abs(value), Math.abs(start), Math.abs(end));
-  return (value / scale - start / scale) / (end / scale - start / scale);
-}
-
-export function interpolateNumber(start, end, proportion) {
-  let result = proportion === 0 ? start : proportion === 1 ? end : undefined;
-  if (result === undefined) {
-    const span = end - start;
-    if (Number.isFinite(span)) {
-      result = start + proportion * span;
-    } else {
-      const scale = Math.max(Math.abs(start), Math.abs(end));
-      result = scale * (
-        start / scale * (1 - proportion) + end / scale * proportion
-      );
-    }
-  }
-  return requireFiniteResult(result, "Numeric interpolation");
-}
-
-export function finiteMidpoint(start, end) {
-  const sum = start + end;
-  const result = Number.isFinite(sum) ? sum / 2 : start / 2 + end / 2;
-  return requireFiniteResult(result, "Numeric midpoint");
-}
-
-export function sampleNumericRange(start, end, count, label = "Numeric range") {
-  const resolution = Math.abs((end - start) / (count - 1));
-  const values = [];
-  const direction = Math.sign(end - start);
-  for (let index = 0; index < count; index += 1) {
-    const value = cleanNumericValue(
-      interpolateNumber(start, end, index / (count - 1)),
-      resolution
-    );
-    if (
-      !Number.isFinite(value) ||
-      (direction !== 0 && index > 0 &&
-        direction * (value - values[index - 1]) <= 0)
-    ) {
-      throw new RangeError(`${label} cannot represent ${count} distinct samples.`);
-    }
-    values.push(value);
-  }
-  return values;
-}
-
-export function formatDistinctNumericSamples(values, initialFormat) {
-  let labels = values.map(initialFormat ?? (value =>
-    String(+value.toPrecision(3))
-  ));
-  const distinct = () => labels.every((label, index) =>
-    index === 0 || values[index] === values[index - 1] ||
-    label !== labels[index - 1]
-  );
-  for (let precision = 4; !distinct() && precision <= 17; precision += 1) {
-    labels = values.map(value => String(+value.toPrecision(precision)));
-  }
-  return distinct() ? labels : values.map(String);
-}
-
-export function stableDecimal(value, places = 12) {
-  if (value === 0) return 0;
-  const threshold = 10 ** -places;
-  return Math.abs(value) < threshold
-    ? Number(value.toPrecision(places))
-    : Number(value.toFixed(places));
-}
+const q=Object.freeze([1,2,3,5]);function h(t,e){if(!Array.isArray(t)||!t.every(Number.isFinite))throw new TypeError(`${e} must contain finite numbers.`)}function p(t){return new RangeError(`${t} is outside the finite numeric range.`)}function x(t,e=1){let n=0,r=0;for(const i of t){const o=i/e,c=n+o;r+=Math.abs(n)>=Math.abs(o)?n-c+o:o-c+n,n=c}return n+r}function f(t){let e=0;for(const n of t)e=Math.max(e,Math.abs(n));return e}function y(t,e="Numeric values"){h(t,e);const n=f(t)||1;return{scale:n,total:x(t,n)}}function b(t,e="Numeric result"){if(!Number.isFinite(t))throw p(e);return t===0?0:t}function N(t,e,n="Numeric result"){if(!Number.isFinite(t)||!Number.isFinite(e)||e<0)throw p(n);return b(t*e,n)}function d(t,e,n=1){h(t,e);const r=t.reduce((o,c)=>o+c,0);if(Number.isFinite(r))return r===0?0:r/n;const i=f(t)||1;return N(x(t,i)/n,i,e)}function $(t,e="Numeric sum"){return d(t,e)}function z(t,e="Numeric sum"){const n=y(t,e);let r=0,i=0,o=0;return t.map(c=>{r+=c;const u=c/n.scale,s=i+u;return o+=Math.abs(i)>=Math.abs(u)?i-s+u:u-s+i,i=s,Number.isFinite(r)?r===0?0:r:N(i+o,n.scale,e)})}function R(t,e="Numeric mean"){if(h(t,e),t.length===0)throw new RangeError(`${e} requires at least one value.`);return d(t,e,t.length)}function P(t,e="Numeric square sum"){h(t,e);const n=t.reduce((c,u)=>c+u**2,0);if(Number.isFinite(n))return n;const r=f(t);if(r===0)return 0;const i=t.reduce((c,u)=>c+(u/r)**2,0),o=N(Math.sqrt(i),r,e);return b(o**2,e)}function A(t,{sample:e=!1,divisor:n=1,label:r="Numeric deviation"}={}){if(!Number.isFinite(n)||n<=0)throw new RangeError(`${r} divisor must be positive and finite.`);const i=t.length-(e?1:0);if(i<=0)throw new RangeError(`${r} requires more values.`);const o=R(t,`${r} mean`),c=t.map(a=>a-o),u=c.reduce((a,M)=>a+M**2,0);if(Number.isFinite(u))return{mean:o,deviation:Math.sqrt(u/i)/n,squared:u};const s=c.every(Number.isFinite),m=s?f(c):Math.max(Math.abs(o),f(t));if(m===0)return{mean:o,deviation:0};const g=t.reduce((a,M,S)=>{const w=s?c[S]/m:M/m-o/m;return a+w**2},0),l=N(Math.sqrt(g/i)/n,m,r);return{mean:o,deviation:l}}function D(t,e){const n=(t.length-1)*e,r=Math.floor(n),i=Math.ceil(n);return F(t[r],t[i],n-r)}function I(t){let e=1/0,n=-1/0;for(const r of t)e=Math.min(e,r),n=Math.max(n,r);return[e,n]}function C(t,e){const n=Math.max(Math.abs(t),Math.abs(e));if(n===0)return{scale:1,start:0,end:0,span:0};const r=10**Math.floor(Math.log10(n)),i=Number.isFinite(r)&&r>0?r:n;return t/=i,e/=i,{scale:i,start:t,end:e,span:e-t}}function O(t,e=5,n=q){if(!Number.isFinite(t)||t<=0)throw new RangeError("Nice numeric span must be positive and finite.");const r=t/Math.max(1,e),i=10**Math.floor(Math.log10(r)),o=r/i;return(n.find(u=>u>=o)??10)*i}function T(t,e,n){let r=t/e;const i=Math.round(r);return Math.abs(r-i)<=1e-10&&(r=i),(n==="floor"?Math.floor(r):Math.ceil(r))*e}function E(t,e){if(!Number.isFinite(t)||t===0)return t===0?0:t;const n=Number(t.toPrecision(15));return Number.isFinite(e)&&e>0&&Math.abs(n-t)<=e*1e-10?n:t}function j(t,e,n){if(t===e)return 0;if(t===n)return 1;const r=n-e,i=t-e;if(Number.isFinite(r)&&r!==0&&Number.isFinite(i))return i/r;const o=Math.max(Math.abs(t),Math.abs(e),Math.abs(n));return(t/o-e/o)/(n/o-e/o)}function F(t,e,n){let r=n===0?t:n===1?e:void 0;if(r===void 0){const i=e-t;if(Number.isFinite(i))r=t+n*i;else{const o=Math.max(Math.abs(t),Math.abs(e));r=o*(t/o*(1-n)+e/o*n)}}return b(r,"Numeric interpolation")}function L(t,e){const n=t+e,r=Number.isFinite(n)?n/2:t/2+e/2;return b(r,"Numeric midpoint")}function V(t,e,n,r="Numeric range"){const i=Math.abs((e-t)/(n-1)),o=[],c=Math.sign(e-t);for(let u=0;u<n;u+=1){const s=E(F(t,e,u/(n-1)),i);if(!Number.isFinite(s)||c!==0&&u>0&&c*(s-o[u-1])<=0)throw new RangeError(`${r} cannot represent ${n} distinct samples.`);o.push(s)}return o}function _(t,e){let n=t.map(e??(i=>String(+i.toPrecision(3))));const r=()=>n.every((i,o)=>o===0||t[o]===t[o-1]||i!==n[o-1]);for(let i=4;!r()&&i<=17;i+=1)n=t.map(o=>String(+o.toPrecision(i)));return r()?n:t.map(String)}function k(t,e=12){if(t===0)return 0;const n=10**-e;return Math.abs(t)<n?Number(t.toPrecision(e)):Number(t.toFixed(e))}export{q as NICE_FACTORS,T as alignNumericStep,E as cleanNumericValue,L as finiteMidpoint,_ as formatDistinctNumericSamples,F as interpolateNumber,j as inverseLerp,f as maximumMagnitude,O as niceNumericStep,C as normalizeNumericRange,y as normalizedFiniteSum,I as numericExtent,D as quantileSorted,b as requireFiniteResult,N as restoreFiniteScale,V as sampleNumericRange,k as stableDecimal,A as stableFiniteDeviation,R as stableFiniteMean,z as stableFinitePrefixSums,P as stableFiniteSquareSum,$ as stableFiniteSum};