ggaction 0.0.17 → 0.0.19

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};

package/src/grammar/scales/size.js

@@ -1,456 +1 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
-import { interpolateNumber } from "../numeric.js";
-import { validateSizeRange, resolveSizeRange } from "./appearance.js";
-import { mapLinearValues } from "./continuous.js";
-import { mapTransformedValues, resolveTransformedDomain } from "./transformed.js";
-import { validateScaleUnknown } from "./policies.js";
-import { validatePair } from "./validation.js";
-
-export const CONTINUOUS_SIZE_SCALE_TYPES = cloneAndFreeze([
-  "linear", "log", "sqrt", "pow"
-]);
-export const DISCRETE_SIZE_SCALE_TYPES = cloneAndFreeze([
-  "quantize", "quantile", "threshold"
-]);
-export const SIZE_SCALE_TYPES = cloneAndFreeze([
-  ...CONTINUOUS_SIZE_SCALE_TYPES,
-  ...DISCRETE_SIZE_SCALE_TYPES
-]);
-
-export function isContinuousSizeScaleType(type) {
-  return CONTINUOUS_SIZE_SCALE_TYPES.includes(type);
-}
-
-export function isDiscreteSizeScaleType(type) {
-  return DISCRETE_SIZE_SCALE_TYPES.includes(type);
-}
-
-export function isSizeScaleType(type) {
-  return SIZE_SCALE_TYPES.includes(type);
-}
-
-export function validateSizeScaleType(type) {
-  if (!isSizeScaleType(type)) {
-    throw new Error(`Scale type "${type}" is not valid for size.`);
-  }
-  return type;
-}
-
-function finiteArray(value, label, minimumLength = 1) {
-  if (
-    !Array.isArray(value) ||
-    value.length < minimumLength ||
-    !value.every(Number.isFinite)
-  ) {
-    throw new TypeError(`${label} must contain finite numbers.`);
-  }
-  return value;
-}
-
-function strictlyIncreasing(value, label) {
-  finiteArray(value, label);
-  if (value.some((item, index) => index > 0 && item <= value[index - 1])) {
-    throw new RangeError(`${label} must be strictly increasing.`);
-  }
-  return value;
-}
-
-function validateContinuousDomain(type, domain) {
-  const validated = validatePair(domain, "Size scale domain");
-  if (type !== "linear" && validated[0] === validated[1]) {
-    throw new RangeError(
-      `Size ${type} scale domain values must be distinct.`
-    );
-  }
-  if (type === "log" && validated.some(value => value <= 0)) {
-    throw new RangeError("Size log scale domain must be strictly positive.");
-  }
-  if (["sqrt", "pow"].includes(type) && validated.some(value => value < 0)) {
-    throw new RangeError(
-      `Size ${type} scale domain must be non-negative.`
-    );
-  }
-  return validated;
-}
-
-export function validateSizeScaleDomain(type, domain) {
-  validateSizeScaleType(type);
-  if (domain === "auto") {
-    if (type === "threshold") {
-      throw new Error("Threshold size scale requires an explicit domain.");
-    }
-    return domain;
-  }
-  if (isContinuousSizeScaleType(type)) {
-    return validateContinuousDomain(type, domain);
-  }
-  if (type === "quantize") {
-    const validated = validatePair(domain, "Quantize size domain");
-    if (validated[0] >= validated[1]) {
-      throw new RangeError(
-        "Quantize size domain must be a strictly increasing pair."
-      );
-    }
-    return validated;
-  }
-  if (type === "quantile") {
-    return cloneAndFreeze(finiteArray(domain, "Quantile size domain"));
-  }
-  return cloneAndFreeze(
-    strictlyIncreasing(domain, "Threshold size domain")
-  );
-}
-
-export function validateDiscreteSizeRange(range) {
-  finiteArray(range, "Discrete size range", 2);
-  validateGeneratedItemLimit(range.length, "Discrete size range length");
-  if (range.some(value => value < 0)) {
-    throw new RangeError(
-      "Discrete size range must contain non-negative areas."
-    );
-  }
-  if (range.some((value, index) => index > 0 && value < range[index - 1])) {
-    throw new RangeError("Discrete size range must be nondecreasing.");
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateSizeScaleRange(type, range) {
-  validateSizeScaleType(type);
-  if (isContinuousSizeScaleType(type)) return validateSizeRange(range);
-  if (range === "auto") {
-    throw new Error(`Size ${type} scale requires an explicit range.`);
-  }
-  return validateDiscreteSizeRange(range);
-}
-
-function sizeTypeFamily(type) {
-  return isContinuousSizeScaleType(type) ? "continuous" : type;
-}
-
-function requireBoolean(value, label) {
-  if (typeof value !== "boolean") {
-    throw new TypeError(`${label} must be a boolean.`);
-  }
-  return value;
-}
-
-function positiveFinite(value, label) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-
-export function normalizeSizeScaleDefinition({ previous = {}, patch = {} } = {}) {
-  const type = validateSizeScaleType(patch.type ?? previous.type ?? "linear");
-  const hasPrevious = previous.type !== undefined;
-  const typeChanged = hasPrevious && previous.type !== type;
-  if (typeChanged && sizeTypeFamily(previous.type) !== sizeTypeFamily(type) &&
-    !Object.hasOwn(patch, "domain")) {
-    throw new Error(
-      "Size scale type-family transition requires an explicit domain."
-    );
-  }
-  if (typeChanged && isDiscreteSizeScaleType(type) &&
-    !Object.hasOwn(patch, "range")) {
-    throw new Error(
-      `Size ${type} scale transition requires an explicit range.`
-    );
-  }
-  if (typeChanged && isDiscreteSizeScaleType(previous.type) &&
-    isContinuousSizeScaleType(type) && !Object.hasOwn(patch, "range")) {
-    throw new Error(
-      "Discrete-to-continuous size scale transition requires an explicit range."
-    );
-  }
-  for (const property of [
-    "nice", "zero", "constant", "padding", "paddingInner", "paddingOuter",
-    "align", "palette", "interpolate", "midpoint", "radialMapping"
-  ]) {
-    if (Object.hasOwn(patch, property)) {
-      throw new Error(`Size scale does not support ${property}.`);
-    }
-  }
-
-  const rawDomain = Object.hasOwn(patch, "domain")
-    ? patch.domain
-    : Object.hasOwn(previous, "domain")
-      ? previous.domain
-      : "auto";
-  const rawRange = Object.hasOwn(patch, "range")
-    ? patch.range
-    : Object.hasOwn(previous, "range")
-      ? previous.range
-      : "auto";
-  const definition = {
-    type,
-    domain: validateSizeScaleDomain(type, rawDomain),
-    range: validateSizeScaleRange(type, rawRange)
-  };
-
-  const reverse = Object.hasOwn(patch, "reverse")
-    ? patch.reverse
-    : previous.reverse;
-  if (reverse !== undefined) {
-    definition.reverse = requireBoolean(reverse, "Size scale reverse");
-  }
-
-  if (isContinuousSizeScaleType(type)) {
-    const clamp = Object.hasOwn(patch, "clamp")
-      ? patch.clamp
-      : isContinuousSizeScaleType(previous.type)
-        ? previous.clamp
-        : undefined;
-    if (clamp !== undefined) {
-      definition.clamp = requireBoolean(clamp, "Size scale clamp");
-    }
-  } else if (Object.hasOwn(patch, "clamp")) {
-    throw new Error(`Size ${type} scale does not support clamp.`);
-  }
-
-  if (type === "log") {
-    const base = Object.hasOwn(patch, "base")
-      ? patch.base
-      : !typeChanged && previous.type === "log"
-        ? previous.base
-        : 10;
-    definition.base = positiveFinite(base ?? 10, "Size log scale base");
-    if (definition.base === 1) {
-      throw new RangeError("Size log scale base must not equal 1.");
-    }
-  } else if (Object.hasOwn(patch, "base")) {
-    throw new Error(`Size ${type} scale does not support base.`);
-  }
-
-  if (type === "pow") {
-    const exponent = Object.hasOwn(patch, "exponent")
-      ? patch.exponent
-      : !typeChanged && previous.type === "pow"
-        ? previous.exponent
-        : undefined;
-    if (exponent === undefined) {
-      throw new Error("Size pow scale requires an explicit exponent.");
-    }
-    definition.exponent = positiveFinite(
-      exponent,
-      "Size pow scale exponent"
-    );
-  } else if (Object.hasOwn(patch, "exponent")) {
-    throw new Error(`Size ${type} scale does not support exponent.`);
-  }
-
-  const unknown = Object.hasOwn(patch, "unknown")
-    ? patch.unknown
-    : previous.unknown;
-  if (unknown !== undefined) {
-    definition.unknown = validateScaleUnknown("size", unknown);
-  }
-  return cloneAndFreeze(definition);
-}
-
-function validateSizeValues(values, type) {
-  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
-    throw new TypeError("Size scale values must be finite numbers.");
-  }
-  if (type === "log" && values.some(value => value <= 0)) {
-    throw new RangeError("Size log scale values must be strictly positive.");
-  }
-  if (["sqrt", "pow"].includes(type) && values.some(value => value < 0)) {
-    throw new RangeError(`Size ${type} scale values must be non-negative.`);
-  }
-  return values;
-}
-
-function numericExtent(values) {
-  let minimum = values[0];
-  let maximum = values[0];
-  for (const value of values.slice(1)) {
-    minimum = Math.min(minimum, value);
-    maximum = Math.max(maximum, value);
-  }
-  return [minimum, maximum];
-}
-
-function resolveContinuousSizeDomain(definition, values) {
-  validateSizeValues(values, definition.type);
-  if (definition.domain !== "auto") {
-    return validateSizeScaleDomain(definition.type, definition.domain);
-  }
-  if (values.length === 0) {
-    throw new Error("Cannot infer an automatic size scale domain from no values.");
-  }
-  if (definition.type === "linear") {
-    return cloneAndFreeze(numericExtent(values));
-  }
-  if (["sqrt", "pow"].includes(definition.type) && values.every(value => value === 0)) {
-    return cloneAndFreeze([0, 1]);
-  }
-  const domain = resolveTransformedDomain({
-    type: definition.type,
-    domain: "auto",
-    values,
-    ...(definition.type === "log" ? { base: definition.base } : {}),
-    ...(definition.type === "pow" ? { exponent: definition.exponent } : {})
-  });
-  return validateSizeScaleDomain(definition.type, domain);
-}
-
-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 resolveSizeScale({
-  type,
-  domain = "auto",
-  range = "auto",
-  values = [],
-  ...options
-} = {}) {
-  const definition = normalizeSizeScaleDefinition({
-    patch: { type, domain, range, ...options }
-  });
-  validateSizeValues(values, definition.type);
-  if (isContinuousSizeScaleType(definition.type)) {
-    const resolvedDomain = resolveContinuousSizeDomain(definition, values);
-    const resolvedRange = [...resolveSizeRange(definition.range)];
-    if (definition.reverse === true) resolvedRange.reverse();
-    return cloneAndFreeze({
-      type: definition.type,
-      domain: resolvedDomain,
-      range: resolvedRange,
-      ...(definition.clamp === undefined ? {} : { clamp: definition.clamp }),
-      ...(definition.type === "log" ? { base: definition.base } : {}),
-      ...(definition.type === "pow" ? { exponent: definition.exponent } : {}),
-      ...(definition.unknown === undefined ? {} : { unknown: definition.unknown })
-    });
-  }
-
-  const resolvedRange = [...definition.range];
-  if (definition.reverse === true) resolvedRange.reverse();
-  const sample = [...values].sort((left, right) => left - right);
-  let resolvedDomain;
-  let thresholds;
-  if (definition.type === "quantize") {
-    if (definition.domain === "auto") {
-      if (sample.length === 0) {
-        throw new Error(
-          "Cannot infer an automatic quantize size domain from no values."
-        );
-      }
-      resolvedDomain = numericExtent(sample);
-      if (resolvedDomain[0] === resolvedDomain[1]) {
-        throw new RangeError(
-          "Quantize size scale requires a non-zero domain span."
-        );
-      }
-    } else {
-      resolvedDomain = [...definition.domain];
-    }
-    thresholds = Array.from(
-      { length: resolvedRange.length - 1 },
-      (_, index) => interpolateNumber(
-        resolvedDomain[0],
-        resolvedDomain[1],
-        (index + 1) / resolvedRange.length
-      )
-    );
-    if (thresholds.some((value, index) =>
-      value <= (index === 0 ? resolvedDomain[0] : thresholds[index - 1]) ||
-      value >= resolvedDomain[1]
-    )) {
-      throw new RangeError(
-        "Quantize size range requests more buckets than its domain can represent."
-      );
-    }
-  } else if (definition.type === "quantile") {
-    const source = definition.domain === "auto"
-      ? sample
-      : [...definition.domain].sort((left, right) => left - right);
-    if (source.length === 0) {
-      throw new Error(
-        "Cannot infer automatic quantile size thresholds from no values."
-      );
-    }
-    resolvedDomain = source;
-    thresholds = Array.from(
-      { length: resolvedRange.length - 1 },
-      (_, index) => quantile(
-        source,
-        (index + 1) / resolvedRange.length
-      )
-    );
-  } else {
-    resolvedDomain = [...definition.domain];
-    thresholds = [...definition.domain];
-    if (resolvedRange.length !== thresholds.length + 1) {
-      throw new RangeError(
-        "Threshold size range must contain exactly one more area than its domain."
-      );
-    }
-  }
-  return cloneAndFreeze({
-    type: definition.type,
-    domain: resolvedDomain,
-    thresholds,
-    range: resolvedRange,
-    ...(definition.unknown === undefined ? {} : { unknown: definition.unknown })
-  });
-}
-
-export function discretizedSizeIndex(value, thresholds) {
-  if (!Number.isFinite(value)) {
-    throw new TypeError("Discrete size values must be finite numbers.");
-  }
-  let index = 0;
-  while (index < thresholds.length && value >= thresholds[index]) index += 1;
-  return index;
-}
-
-function validateMappedAreas(areas) {
-  if (areas.some(area => !Number.isFinite(area) || area < 0)) {
-    throw new RangeError(
-      "Size scale mapping must produce non-negative finite areas."
-    );
-  }
-  return cloneAndFreeze(areas);
-}
-
-export function mapSizeValues(values, scale) {
-  validateSizeScaleType(scale?.type);
-  const hasUnknown = Object.hasOwn(scale, "unknown");
-  const finite = values.filter(Number.isFinite);
-  validateSizeValues(finite, scale.type);
-  if (!hasUnknown && finite.length !== values.length) {
-    throw new TypeError("Size scale values must be finite numbers.");
-  }
-  let mapped;
-  if (isDiscreteSizeScaleType(scale.type)) {
-    mapped = values.map(value => {
-      if (!Number.isFinite(value)) return scale.unknown;
-      return scale.range[discretizedSizeIndex(value, scale.thresholds)];
-    });
-  } else if (scale.type === "linear") {
-    mapped = mapLinearValues(values, scale.domain, scale.range, {
-      clamp: scale.clamp ?? false,
-      ...(hasUnknown ? { unknown: scale.unknown } : {})
-    });
-  } else {
-    mapped = mapTransformedValues(values, scale.domain, scale.range, {
-      type: scale.type,
-      clamp: scale.clamp ?? false,
-      ...(hasUnknown ? { unknown: scale.unknown } : {}),
-      ...(scale.type === "log" ? { base: scale.base } : {}),
-      ...(scale.type === "pow" ? { exponent: scale.exponent } : {})
-    });
-  }
-  return validateMappedAreas(mapped);
-}
+import{cloneAndFreeze as u}from"../../core/immutable.js";import{validateGeneratedItemLimit as g,validatePositiveFinite as R}from"../../core/validation.js";import{interpolateNumber as $,numericExtent as q}from"../numeric.js";import{isNominalValue as A}from"./fields.js";import{resolveOrdinalDomain as C,validateOrdinalDomain as I}from"./ordinal.js";import{mapLinearValues as _}from"./continuous.js";import{mapTransformedValues as j,resolveTransformedDomain as F}from"./transformed.js";import{validateSizeRange as N,DEFAULT_SIZE_RANGE as P,mapOrdinalValues as L}from"./appearance.js";import{validateScaleUnknown as V}from"./policies.js";import{validatePair as U,validateFiniteScaleArray as E}from"./validation.js";import{resolveDiscretizedDomain as Z,validateDiscretizedDomain as Y,discretizedColorIndex as G}from"./discretized.js";const x=u(["linear","log","sqrt","pow"]),O=u(["quantize","quantile","threshold"]),M=u([...x,...O,"ordinal"]);function m(e){return x.includes(e)}function f(e){return O.includes(e)}function ce(e){return e==="ordinal"||f(e)}function B(e){return M.includes(e)}function w(e){if(!B(e))throw new Error(`Scale type "${e}" is not valid for size.`);return e}function v(e,n,t){if(n==="log"&&e.some(o=>o<=0))throw new RangeError(`Size log scale ${t} must be strictly positive.`);if(["sqrt","pow"].includes(n)&&e.some(o=>o<0))throw new RangeError(`Size ${n} scale ${t} must be non-negative.`);return e}function H(e,n){const t=U(n,"Size scale domain");if(e!=="linear"&&t[0]===t[1])throw new RangeError(`Size ${e} scale domain values must be distinct.`);return v(t,e,"domain")}function z(e,n){return w(e),e==="ordinal"?I(n):m(e)?n==="auto"?n:H(e,n):Y(e,n,"size")}function J(e){if(E(e,"Discrete size range",2),g(e.length,"Discrete size range length"),e.some(n=>n<0))throw new RangeError("Discrete size range must contain non-negative areas.");if(e.some((n,t)=>t>0&&n<e[t-1]))throw new RangeError("Discrete size range must be nondecreasing.");return u(e)}function K(e,n){if(w(e),m(e))return N(n);if(e==="ordinal")return n==="auto"?n:(E(n,"Ordinal size range"),g(n.length,"Ordinal size range length"),y(n));if(n==="auto")throw new Error(`Size ${e} scale requires an explicit range.`);return J(n)}function D(e){return m(e)?"continuous":e}function Q({previous:e={},patch:n={}}={}){const t=w(n.type??e.type??"linear"),s=e.type!==void 0&&e.type!==t;if(s&&D(e.type)!==D(t)&&!Object.hasOwn(n,"domain"))throw new Error("Size scale type-family transition requires an explicit domain.");if(s&&f(t)&&!Object.hasOwn(n,"range"))throw new Error(`Size ${t} scale transition requires an explicit range.`);if(s&&f(e.type)&&m(t)&&!Object.hasOwn(n,"range"))throw new Error("Discrete-to-continuous size scale transition requires an explicit range.");for(const i of["nice","zero","constant","padding","paddingInner","paddingOuter","align","palette","interpolate","midpoint","radialMapping"])if(Object.hasOwn(n,i))throw new Error(`Size scale does not support ${i}.`);const r={domain:"auto",range:"auto",...e,...n},a={type:t,domain:z(t,r.domain),range:K(t,r.range)};for(const i of["reverse","clamp"]){if(i==="clamp"&&!m(t)){if(Object.hasOwn(n,i))throw new Error(`Size ${t} scale does not support clamp.`);continue}const p=Object.hasOwn(n,i)?n[i]:i==="clamp"&&!m(e.type)?void 0:e[i];if(p!==void 0){if(typeof p!="boolean")throw new TypeError(`Size scale ${i} must be a boolean.`);a[i]=p}}for(const[i,p,c]of[["base","log",10],["exponent","pow"]]){if(t!==p){if(Object.hasOwn(n,i))throw new Error(`Size ${t} scale does not support ${i}.`);continue}const l=Object.hasOwn(n,i)?n[i]:!s&&e.type===p?e[i]:c;if(i==="exponent"&&l===void 0)throw new Error("Size pow scale requires an explicit exponent.");if(a[i]=R(i==="base"?l??c:l,`Size ${t} scale ${i}`),i==="base"&&a.base===1)throw new RangeError("Size log scale base must not equal 1.")}const d=Object.hasOwn(n,"unknown")?n.unknown:e.unknown;return d!==void 0&&(a.unknown=V("size",d)),u(a)}function k(e,n){if(!Array.isArray(e)||!e.every(Number.isFinite))throw new TypeError("Size scale values must be finite numbers.");return v(e,n,"values")}function W(e,n){if(e.domain!=="auto")return z(e.type,e.domain);if(n.length===0)throw new Error("Cannot infer an automatic size scale domain from no values.");if(e.type==="linear")return u(q(n));if(["sqrt","pow"].includes(e.type)&&n.every(o=>o===0))return u([0,1]);const t=F({type:e.type,domain:"auto",values:n,...e.type==="log"?{base:e.base}:{},...e.type==="pow"?{exponent:e.exponent}:{}});return z(e.type,t)}function fe({type:e,domain:n="auto",range:t="auto",values:o=[],...s}={}){const r=Q({patch:{type:e,domain:n,range:t,...s}}),a=r.type==="ordinal",d=a?o.filter(A):k(o,r.type);if(a&&d.length!==o.length&&r.unknown===void 0)throw new TypeError("Ordinal size values must be nominal values.");if(a||m(r.type)){const l=a?C(r.domain,d):W(r,o);a&&g(l.length,"Ordinal size domain length");const S=r.range==="auto"?P:r.range,h=a&&r.range==="auto"?l.map((ne,T)=>$(S[0],S[1],l.length===1?.5:T/(l.length-1))):[...S];r.reverse===!0&&h.reverse();const b=u({type:r.type,domain:l,range:h,...r.clamp===void 0?{}:{clamp:r.clamp},...r.type==="log"?{base:r.base}:{},...r.type==="pow"?{exponent:r.exponent}:{},...r.unknown===void 0?{}:{unknown:r.unknown}});return a&&ee(o,b),b}const i=[...r.range];r.reverse===!0&&i.reverse();const{domain:p,thresholds:c}=Z({type:r.type,domain:r.domain,values:o,count:i.length,kind:"size"});return u({type:r.type,domain:p,thresholds:c,range:i,...r.unknown===void 0?{}:{unknown:r.unknown}})}function X(e,n){return G(e,n,"Discrete size")}function y(e){if(e.some(n=>!Number.isFinite(n)||n<0))throw new RangeError("Size scale mapping must produce non-negative finite areas.");return u(e)}function ee(e,n){w(n?.type);const t=Object.hasOwn(n,"unknown");if(n.type==="ordinal")return y(L(e,n.domain,n.range,t?{unknown:n.unknown}:{}));const o=e.filter(Number.isFinite);if(k(o,n.type),!t&&o.length!==e.length)throw new TypeError("Size scale values must be finite numbers.");let s;return f(n.type)?s=e.map(r=>Number.isFinite(r)?n.range[X(r,n.thresholds)]:n.unknown):s=(n.type==="linear"?_:j)(e,n.domain,n.range,{type:n.type,clamp:n.clamp??!1,...t?{unknown:n.unknown}:{},...n.type==="log"?{base:n.base}:{},...n.type==="pow"?{exponent:n.exponent}:{}}),y(s)}export{x as CONTINUOUS_SIZE_SCALE_TYPES,O as DISCRETE_SIZE_SCALE_TYPES,M as SIZE_SCALE_TYPES,X as discretizedSizeIndex,m as isContinuousSizeScaleType,f as isDiscreteSizeScaleType,ce as isEnumeratedSizeScaleType,B as isSizeScaleType,ee as mapSizeValues,Q as normalizeSizeScaleDefinition,fe as resolveSizeScale,J as validateDiscreteSizeRange,z as validateSizeScaleDomain,K as validateSizeScaleRange,w as validateSizeScaleType};