ggaction 0.0.17 → 0.0.18

package/src/grammar/scales/definition.js

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

package/src/grammar/scales/discretized.js

@@ -1,195 +1 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
-import { interpolateNumber } from "../numeric.js";
-import { formatValue, validateValueFormat } from "../valueFormat.js";
-import { resolveColorRange, validateColorRange } from "./appearance.js";
-import { SCALE_ROLES, validateScaleTypeForRole } from "./types.js";
-
-export const DISCRETIZED_COLOR_SCALE_TYPES = cloneAndFreeze([
-  "quantize",
-  "quantile",
-  "threshold"
-]);
-
-function finiteValues(values, label) {
-  if (!Array.isArray(values) || values.length === 0 || !values.every(Number.isFinite)) {
-    throw new TypeError(`${label} must contain finite numbers.`);
-  }
-  return values;
-}
-
-function ascending(values, label) {
-  finiteValues(values, label);
-  if (values.some((value, index) => index > 0 && value <= values[index - 1])) {
-    throw new RangeError(`${label} must be strictly increasing.`);
-  }
-  return values;
-}
-
-function nondecreasing(values, label) {
-  finiteValues(values, label);
-  if (values.some((value, index) => index > 0 && value < values[index - 1])) {
-    throw new RangeError(`${label} must be nondecreasing.`);
-  }
-  return values;
-}
-
-function quantile(sorted, probability) {
-  const position = (sorted.length - 1) * probability;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  return interpolateNumber(sorted[lower], sorted[upper], position - lower);
-}
-
-export function validateDiscretizedColorDomain(type, domain) {
-  validateScaleTypeForRole(type, SCALE_ROLES.discretizedColor);
-  if (domain === "auto") {
-    if (type === "threshold") {
-      throw new Error("Threshold color scale requires an explicit domain.");
-    }
-    return domain;
-  }
-  if (!Array.isArray(domain)) {
-    throw new TypeError("Discretized color domain must be an array or auto.");
-  }
-  if (type === "quantize") {
-    if (domain.length !== 2 || !domain.every(Number.isFinite) || domain[0] >= domain[1]) {
-      throw new RangeError("Quantize color domain must be an increasing pair.");
-    }
-  } else if (type === "quantile") {
-    finiteValues(domain, "Quantile color domain");
-  } else {
-    ascending(domain, "Threshold color domain");
-  }
-  return cloneAndFreeze(domain);
-}
-
-export function validateDiscretizedColorRange(range) {
-  if (Array.isArray(range)) {
-    validateGeneratedItemLimit(
-      range.length,
-      "Discretized color range length"
-    );
-  }
-  const validated = validateColorRange(range);
-  if (validated === "auto") return validated;
-  if (Array.isArray(validated) && validated.length < 2) {
-    throw new RangeError("Discretized color range requires at least two colors.");
-  }
-  return validated;
-}
-
-export function resolveDiscretizedColorScale({ type, domain, range, values }) {
-  validateScaleTypeForRole(type, SCALE_ROLES.discretizedColor);
-  finiteValues(values, "Discretized color values");
-  const requestedDomain = validateDiscretizedColorDomain(type, domain);
-  const sample = [...values].sort((left, right) => left - right);
-  const validatedRange = validateDiscretizedColorRange(range);
-  const colorCount = type === "threshold"
-    ? requestedDomain.length + 1
-    : Array.isArray(range) ? range.length : 5;
-  const colors = resolveColorRange(
-    validatedRange === "auto" ? { palette: "viridis" } : validatedRange,
-    colorCount
-  );
-  if (colors.length < 2) {
-    throw new RangeError("Discretized color range requires at least two colors.");
-  }
-  let resolvedDomain;
-  let thresholds;
-  if (type === "quantize") {
-    resolvedDomain = requestedDomain === "auto"
-      ? [sample[0], sample.at(-1)]
-      : [...requestedDomain];
-    if (resolvedDomain[0] === resolvedDomain[1]) {
-      throw new RangeError("Quantize color scale requires a non-zero domain span.");
-    }
-    thresholds = Array.from(
-      { length: colors.length - 1 },
-      (_, index) => interpolateNumber(
-        resolvedDomain[0],
-        resolvedDomain[1],
-        (index + 1) / colors.length
-      )
-    );
-    if (thresholds.some((value, index) =>
-      value <= (index === 0 ? resolvedDomain[0] : thresholds[index - 1]) ||
-      value >= resolvedDomain[1]
-    )) {
-      throw new RangeError(
-        "Quantize color range requests more classes than its numeric domain can represent."
-      );
-    }
-  } else if (type === "quantile") {
-    const source = requestedDomain === "auto"
-      ? sample
-      : [...requestedDomain].sort((left, right) => left - right);
-    resolvedDomain = source;
-    thresholds = Array.from(
-      { length: colors.length - 1 },
-      (_, index) => quantile(source, (index + 1) / colors.length)
-    );
-  } else {
-    resolvedDomain = [...requestedDomain];
-    thresholds = [...requestedDomain];
-    if (colors.length !== thresholds.length + 1) {
-      throw new RangeError(
-        "Threshold color range must contain exactly one more color than its domain."
-      );
-    }
-  }
-  return cloneAndFreeze({
-    type,
-    domain: resolvedDomain,
-    thresholds,
-    range: colors
-  });
-}
-
-export function discretizedColorIndex(value, thresholds) {
-  if (!Number.isFinite(value)) {
-    throw new TypeError("Discretized color values must be finite numbers.");
-  }
-  let index = 0;
-  while (index < thresholds.length && value >= thresholds[index]) index += 1;
-  return index;
-}
-
-export function mapDiscretizedColors(values, scale) {
-  const hasUnknown = Object.hasOwn(scale, "unknown");
-  return cloneAndFreeze(values.map(value => {
-    if (!Number.isFinite(value) && hasUnknown) return scale.unknown;
-    return scale.range[discretizedColorIndex(value, scale.thresholds)];
-  }));
-}
-
-export function formatDiscretizedIntervals(thresholds, format = "auto") {
-  nondecreasing(thresholds, "Discretized color thresholds");
-  const resolvedFormat = validateValueFormat(format, "Legend label format");
-  let resolution = Infinity;
-  for (let index = 1; index < thresholds.length; index += 1) {
-    const gap = thresholds[index] - thresholds[index - 1];
-    if (Number.isFinite(gap) && gap > 0) resolution = Math.min(resolution, gap);
-  }
-  let labels = resolvedFormat === "auto"
-    ? thresholds.map(value => Number.isInteger(value) ? String(value) : value.toFixed(1))
-    : thresholds.map(value => formatValue(value, {
-        format: resolvedFormat,
-        valueType: "quantitative",
-        label: "Legend label format"
-      }));
-  if (resolvedFormat === "auto" && thresholds.some((value, index) => {
-    const rounded = Number(labels[index]);
-    return value !== 0 && rounded === 0 ||
-      index > 0 && value !== thresholds[index - 1] &&
-        labels[index] === labels[index - 1] ||
-      !Number.isInteger(value) && Math.abs(rounded - value) > resolution / 4;
-  })) labels = thresholds.map(String);
-  return cloneAndFreeze([
-    `< ${labels[0]}`,
-    ...labels.slice(0, -1).map((value, index) =>
-      `${value}–${labels[index + 1]}`
-    ),
-    `≥ ${labels.at(-1)}`
-  ]);
-}
+import{cloneAndFreeze as c}from"../../core/immutable.js";import{validateGeneratedItemLimit as g}from"../../core/validation.js";import{interpolateNumber as h,quantileSorted as z}from"../numeric.js";import{formatValue as w,validateValueFormat as p}from"../valueFormat.js";import{resolveColorRange as D,validateColorRange as b}from"./appearance.js";import{SCALE_ROLES as m,validateScaleTypeForRole as f}from"./types.js";import{validatePair as E,validateFiniteScaleArray as u,validateIncreasingScaleArray as q}from"./validation.js";const Q=c(["quantize","quantile","threshold"]);function C(r,e){if(u(r,e),r.some((i,o)=>o>0&&i<r[o-1]))throw new RangeError(`${e} must be nondecreasing.`);return r}function R(r,e){return f(r,m.discretizedColor),v(r,e,"color")}function v(r,e,i){if(e==="auto"){if(r==="threshold")throw new Error(`Threshold ${i} scale requires an explicit domain.`);return e}if(i==="color"&&!Array.isArray(e))throw new TypeError("Discretized color domain must be an array or auto.");if(r==="quantize"){if(i==="size"){if(E(e,"Quantize size domain"),e[0]>=e[1])throw new RangeError("Quantize size domain must be a strictly increasing pair.")}else if(e.length!==2||!e.every(Number.isFinite)||e[0]>=e[1])throw new RangeError("Quantize color domain must be an increasing pair.")}else r==="quantile"?u(e,`Quantile ${i} domain`):q(e,`Threshold ${i} domain`);return c(e)}function A(r){Array.isArray(r)&&g(r.length,"Discretized color range length");const e=b(r);if(e==="auto")return e;if(Array.isArray(e)&&e.length<2)throw new RangeError("Discretized color range requires at least two colors.");return e}function y({type:r,domain:e,values:i,count:o,kind:a}){let t=e==="auto"?[...i].sort((s,l)=>s-l):[...e],n;if(r==="quantize"){if(e==="auto"){if(t.length===0)throw new Error("Cannot infer an automatic quantize size domain from no values.");t=[t[0],t.at(-1)]}if(t[0]===t[1])throw new RangeError(`Quantize ${a} scale requires a non-zero domain span.`);if(n=Array.from({length:o-1},(s,l)=>h(t[0],t[1],(l+1)/o)),n.some((s,l)=>s<=(l===0?t[0]:n[l-1])||s>=t[1]))throw new RangeError(a==="size"?"Quantize size range requests more buckets than its domain can represent.":"Quantize color range requests more classes than its numeric domain can represent.")}else if(r==="quantile"){if(t.length===0)throw new Error("Cannot infer automatic quantile size thresholds from no values.");t.sort((s,l)=>s-l),n=Array.from({length:o-1},(s,l)=>z(t,(l+1)/o))}else if(n=[...t],o!==n.length+1)throw new RangeError(`Threshold ${a} range must contain exactly one more ${a==="size"?"area":"color"} than its domain.`);return{domain:t,thresholds:n}}function _({type:r,domain:e,range:i,values:o}){f(r,m.discretizedColor),u(o,"Discretized color values");const a=R(r,e),t=A(i),n=r==="threshold"?a.length+1:Array.isArray(i)?i.length:5,s=D(t==="auto"?{palette:"viridis"}:t,n);if(s.length<2)throw new RangeError("Discretized color range requires at least two colors.");const{domain:l,thresholds:d}=y({type:r,domain:a,values:o,count:s.length,kind:"color"});return c({type:r,domain:l,thresholds:d,range:s})}function S(r,e,i="Discretized color"){if(!Number.isFinite(r))throw new TypeError(`${i} values must be finite numbers.`);let o=0;for(;o<e.length&&r>=e[o];)o+=1;return o}function O(r,e){const i=Object.hasOwn(e,"unknown");return c(r.map(o=>!Number.isFinite(o)&&i?e.unknown:e.range[S(o,e.thresholds)]))}function V(r,e="auto"){C(r,"Discretized color thresholds");const i=p(e,"Legend label format");let o=1/0;for(let t=1;t<r.length;t+=1){const n=r[t]-r[t-1];Number.isFinite(n)&&n>0&&(o=Math.min(o,n))}let a=i==="auto"?r.map(t=>Number.isInteger(t)?String(t):t.toFixed(1)):r.map(t=>w(t,{format:i,valueType:"quantitative",label:"Legend label format"}));return i==="auto"&&r.some((t,n)=>{const s=Number(a[n]);return t!==0&&s===0||n>0&&t!==r[n-1]&&a[n]===a[n-1]||!Number.isInteger(t)&&Math.abs(s-t)>o/4})&&(a=r.map(String)),c([`< ${a[0]}`,...a.slice(0,-1).map((t,n)=>`${t}\u2013${a[n+1]}`),`\u2265 ${a.at(-1)}`])}export{Q as DISCRETIZED_COLOR_SCALE_TYPES,S as discretizedColorIndex,V as formatDiscretizedIntervals,O as mapDiscretizedColors,_ as resolveDiscretizedColorScale,y as resolveDiscretizedDomain,R as validateDiscretizedColorDomain,A as validateDiscretizedColorRange,v as validateDiscretizedDomain};