@faintshadow/flarecharts 26.3.1

package/dist/core/merge.js

@@ -0,0 +1,46 @@
+/**
+ * Options precedence merge — Data chain, as one tiny utility:
+ *
+ *   chart defaults < chart-level plotOptions < per-series options < per-point options
+ *
+ * Call it with layers in ascending precedence; later layers win:
+ *
+ *   mergeOptions(defaults, plotOptions, series.options, point.options)
+ *
+ * Rules:
+ *   - plain objects merge recursively
+ *   - everything else (arrays, Dates, functions, class instances, scalars) replaces
+ *   - `undefined` values are skipped (do not overwrite)
+ *   - `null` values DO overwrite (explicit "clear this option")
+ *   - inputs are never mutated; nested plain objects are cloned
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function mergeInto(target, layer) {
+    for (const key of Object.keys(layer)) {
+        const value = layer[key];
+        if (value === undefined)
+            continue;
+        const previous = target[key];
+        if (isPlainObject(value)) {
+            target[key] = mergeInto(isPlainObject(previous) ? previous : {}, value);
+        }
+        else {
+            target[key] = value;
+        }
+    }
+    return target;
+}
+export function mergeOptions(...layers) {
+    const out = {};
+    for (const layer of layers) {
+        if (layer == null)
+            continue;
+        mergeInto(out, layer);
+    }
+    return out;
+}

package/dist/core/motion.svelte.d.ts

@@ -0,0 +1,31 @@
+/** True only in the browser when the user HAS requested reduced motion. */
+export declare function prefersReducedMotion(): boolean;
+/** Parse a CSS duration token ("500ms" | "0.5s" | "") to milliseconds. Pure. */
+export declare function parseDuration(value: string, fallback?: number): number;
+/** Effective enter/update duration for an element: reads --fc-duration, 0 when
+ *  reduced motion or no element (server). Client-only. */
+export declare function motionDuration(el: Element | undefined | null, fallback?: number): number;
+/** Phase factors for the box entrance, given overall progress p (0..1):
+ *  frame (caps+whiskers) leads, box grows in the middle, median trails. Pure. */
+export declare function boxEnterPhases(p: number): {
+    frame: number;
+    grow: number;
+    median: number;
+};
+type Tweenable = number | number[] | Record<string, number>;
+/**
+ * A tweened value. On the server and first paint it equals `target()` (no
+ * motion). On mount, if motion is enabled it snaps to `collapsed()` then
+ * animates to `target()` (enter). Later `target()` changes animate (update).
+ */
+export declare function motionValue<T extends Tweenable>(target: () => T, collapsed: () => T, getEl: () => Element | undefined): {
+    readonly current: T;
+};
+/**
+ * Morphs an SVG path `d` on update via d3-interpolate-path. Enter is handled by
+ * the component's CSS (draw-on), so the first paint just shows `target()`.
+ */
+export declare function motionPath(target: () => string, getEl: () => Element | undefined): {
+    readonly d: string;
+};
+export {};

package/dist/core/motion.svelte.js

@@ -0,0 +1,129 @@
+/**
+ * Motion helpers — pure math + two reactive tween wrappers.
+ *
+ * Philosophy mirrors the rest of the library: Svelte + CSS for motion, never an
+ * imperative animation engine. The animation loop/easing is Svelte's first-party
+ * `Tween`; path morphing is `d3-interpolate-path`. Everything reads its timing
+ * from the `--fc-duration` CSS token and respects `prefers-reduced-motion`.
+ */
+import { Tween } from 'svelte/motion';
+import { cubicOut } from 'svelte/easing';
+import { interpolatePath } from 'd3-interpolate-path';
+/** True only in the browser when the user HAS requested reduced motion. */
+export function prefersReducedMotion() {
+    return (typeof window !== 'undefined' &&
+        typeof window.matchMedia === 'function' &&
+        window.matchMedia('(prefers-reduced-motion: reduce)').matches);
+}
+/** Parse a CSS duration token ("500ms" | "0.5s" | "") to milliseconds. Pure. */
+export function parseDuration(value, fallback = 500) {
+    const v = (value ?? '').trim();
+    const m = /^([\d.]+)(ms|s)?$/.exec(v);
+    if (!m)
+        return fallback;
+    const n = parseFloat(m[1]);
+    if (!Number.isFinite(n))
+        return fallback;
+    return m[2] === 's' ? n * 1000 : n;
+}
+/** Effective enter/update duration for an element: reads --fc-duration, 0 when
+ *  reduced motion or no element (server). Client-only. */
+export function motionDuration(el, fallback = 500) {
+    if (!el || typeof window === 'undefined')
+        return 0;
+    if (prefersReducedMotion())
+        return 0;
+    const raw = getComputedStyle(el).getPropertyValue('--fc-duration');
+    return parseDuration(raw, fallback);
+}
+/** Phase factors for the box entrance, given overall progress p (0..1):
+ *  frame (caps+whiskers) leads, box grows in the middle, median trails. Pure. */
+export function boxEnterPhases(p) {
+    const c = (x) => Math.max(0, Math.min(1, x));
+    return { frame: c(p / 0.2), grow: c((p - 0.15) / 0.6), median: c((p - 0.75) / 0.25) };
+}
+const arrLen = (v) => (Array.isArray(v) ? v.length : -1);
+/**
+ * A tweened value. On the server and first paint it equals `target()` (no
+ * motion). On mount, if motion is enabled it snaps to `collapsed()` then
+ * animates to `target()` (enter). Later `target()` changes animate (update).
+ */
+export function motionValue(target, collapsed, getEl) {
+    // Duration read live so runtime --fc-duration / reduced-motion changes apply.
+    const tw = new Tween(target(), { duration: () => motionDuration(getEl()), easing: cubicOut });
+    let entered = false;
+    let prevLen = arrLen(target());
+    $effect(() => {
+        const tgt = target();
+        const len = arrLen(tgt);
+        if (!entered) {
+            entered = true;
+            prevLen = len;
+            if (motionDuration(getEl()) > 0) {
+                tw.set(collapsed(), { duration: 0 });
+                tw.set(tgt);
+            }
+            else {
+                tw.set(tgt, { duration: 0 });
+            }
+        }
+        else if (len !== prevLen) {
+            // Structural change (point count differs) — snap, don't interpolate mismatched arrays.
+            prevLen = len;
+            tw.set(tgt, { duration: 0 });
+        }
+        else {
+            tw.target = tgt;
+        }
+    });
+    return {
+        get current() {
+            return tw.current;
+        }
+    };
+}
+/**
+ * Morphs an SVG path `d` on update via d3-interpolate-path. Enter is handled by
+ * the component's CSS (draw-on), so the first paint just shows `target()`.
+ */
+export function motionPath(target, getEl) {
+    const t = new Tween(1, { duration: () => motionDuration(getEl()), easing: cubicOut });
+    let entered = false;
+    let animating = $state(false);
+    let interp = () => target();
+    // `displayed` mirrors `shown` but is non-reactive, so the morph-trigger effect
+    // depends only on target() — never on the per-frame `shown` writes (no loop).
+    let displayed = target();
+    let shown = $state(target());
+    $effect(() => {
+        const tgt = target();
+        if (!entered) {
+            entered = true;
+            shown = tgt;
+            displayed = tgt;
+            return;
+        }
+        if (motionDuration(getEl()) > 0) {
+            interp = interpolatePath(displayed, tgt);
+            animating = true;
+            t.set(0, { duration: 0 });
+            t.set(1);
+        }
+        else {
+            animating = false;
+            shown = tgt;
+            displayed = tgt;
+        }
+    });
+    $effect(() => {
+        if (animating) {
+            shown = interp(t.current);
+            displayed = shown;
+        }
+    });
+    return {
+        get d() {
+            return shown;
+        }
+    };
+}

package/dist/core/normalize.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Series data normalizer.
+ *
+ * Every mark component (`<Line>`, `<Area>`, `<Points>`, …) accepts the same
+ * input shapes:
+ *
+ *   - `number[]`                      → y values, x is the array index
+ *   - `[x, y][]`                      → tuples; x may be number | string | Date
+ *   - `{ x, y, ... }[]`               → point objects (extra keys pass through)
+ *   - `T[]` + `x`/`y` accessor fns    → arbitrary data, you tell us where x/y live
+ *
+ * `null` (or `NaN`/`±Infinity`) y values become gaps, never zeros.
+ * One normalizer, used everywhere, heavily tested.
+ */
+/** Any value usable on the x axis. Strings imply a band (category) scale. */
+export type XValue = number | string | Date;
+export interface NormalizedPoint<T = unknown> {
+    x: XValue;
+    y: number | null;
+    /** The original datum, untouched — flows into snippets (tooltips, labels). */
+    datum: T;
+    index: number;
+}
+export interface PointAccessors<T = unknown> {
+    x?: (datum: T, index: number) => XValue;
+    y?: (datum: T, index: number) => number | null | undefined;
+}
+/**
+ * Normalize any supported data shape into `NormalizedPoint[]`.
+ * Accessors win over inference; partial accessors are fine
+ * (e.g. only `y` for `number[]`-like data with index x).
+ */
+export declare function normalizePoints<T>(data: readonly T[], accessors?: PointAccessors<T>): NormalizedPoint<T>[];
+/** What kind of x values a point list carries — drives x scale type inference. */
+export declare function xKindOf(points: readonly NormalizedPoint[]): 'number' | 'date' | 'category';

package/dist/core/normalize.js

@@ -0,0 +1,97 @@
+/**
+ * Series data normalizer.
+ *
+ * Every mark component (`<Line>`, `<Area>`, `<Points>`, …) accepts the same
+ * input shapes:
+ *
+ *   - `number[]`                      → y values, x is the array index
+ *   - `[x, y][]`                      → tuples; x may be number | string | Date
+ *   - `{ x, y, ... }[]`               → point objects (extra keys pass through)
+ *   - `T[]` + `x`/`y` accessor fns    → arbitrary data, you tell us where x/y live
+ *
+ * `null` (or `NaN`/`±Infinity`) y values become gaps, never zeros.
+ * One normalizer, used everywhere, heavily tested.
+ */
+function toX(value, index) {
+    if (value == null)
+        return index;
+    if (typeof value === 'number' || typeof value === 'string' || value instanceof Date) {
+        return value;
+    }
+    throw new Error(`flarechart: x value at index ${index} is not a number, string or Date (got ${typeof value}). Provide an \`x\` accessor.`);
+}
+function toY(value, index) {
+    if (value == null)
+        return null;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    throw new Error(`flarechart: y value at index ${index} is not a number (got ${typeof value}). Provide a \`y\` accessor.`);
+}
+function inferPoint(item, index, needX, needY) {
+    // number[] (null = gap)
+    if (item == null)
+        return { x: index, y: null };
+    if (typeof item === 'number')
+        return { x: index, y: toY(item, index) };
+    // [x, y][]
+    if (Array.isArray(item)) {
+        if (item.length < 2) {
+            throw new Error(`flarechart: tuple at index ${index} needs [x, y], got length ${item.length}.`);
+        }
+        return { x: toX(item[0], index), y: toY(item[1], index) };
+    }
+    // { x?, y }[]
+    if (typeof item === 'object') {
+        const o = item;
+        const hasY = 'y' in o;
+        if (needY && !hasY) {
+            throw new Error(`flarechart: cannot infer y from datum at index ${index} — no \`y\` key. Provide a \`y\` accessor.`);
+        }
+        return {
+            x: 'x' in o ? toX(o.x, index) : index,
+            y: hasY ? toY(o.y, index) : null
+        };
+    }
+    if (needX || needY) {
+        throw new Error(`flarechart: cannot infer a point from datum at index ${index} (got ${typeof item}). Provide x/y accessors.`);
+    }
+    return { x: index, y: null };
+}
+/**
+ * Normalize any supported data shape into `NormalizedPoint[]`.
+ * Accessors win over inference; partial accessors are fine
+ * (e.g. only `y` for `number[]`-like data with index x).
+ */
+export function normalizePoints(data, accessors = {}) {
+    const out = new Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        const datum = data[i];
+        let x;
+        let y;
+        if (accessors.x)
+            x = toX(accessors.x(datum, i), i);
+        if (accessors.y)
+            y = toY(accessors.y(datum, i), i);
+        if (x === undefined || y === undefined) {
+            const inferred = inferPoint(datum, i, x === undefined, y === undefined);
+            if (x === undefined)
+                x = inferred.x;
+            if (y === undefined)
+                y = inferred.y;
+        }
+        out[i] = { x, y, datum, index: i };
+    }
+    return out;
+}
+/** What kind of x values a point list carries — drives x scale type inference. */
+export function xKindOf(points) {
+    const p = points.find((pt) => pt.x != null);
+    if (!p)
+        return 'number';
+    if (p.x instanceof Date)
+        return 'date';
+    if (typeof p.x === 'string')
+        return 'category';
+    return 'number';
+}

package/dist/core/options.d.ts

@@ -0,0 +1,113 @@
+import type { XValue } from './normalize.js';
+import type { CurveName } from './curves.js';
+import type { StackOffset, StackOrder } from './stack.js';
+import type { AxisOptions } from './types.js';
+import type { TooltipMode } from './hit.js';
+import type { WhiskerMode } from './stats.js';
+import type { SymbolName } from './symbols.js';
+export type MarkerMode = 'always' | 'hover' | 'none';
+export interface SeriesOptions<T = unknown> {
+    name?: string;
+    data: readonly T[];
+    x?: (datum: T, index: number) => XValue;
+    y?: (datum: T, index: number) => number | null | undefined;
+    /** Any CSS color string — passed through untouched. */
+    color?: string;
+    /** Per-point color override — the end of the precedence chain. */
+    colorFor?: (datum: T, index: number) => string | undefined;
+    /** Accessible series description (announced when keyboard focus enters the series). */
+    description?: string;
+    curve?: CurveName;
+    strokeWidth?: number;
+    /** Areas only. */
+    fillOpacity?: number;
+    /** Bars/areas. normal/percent anchor at zero; stream/silhouette float (areas). */
+    stacking?: StackOffset;
+    /** Layer ordering within the stack group. */
+    order?: StackOrder;
+    stack?: string;
+    /** Bars only. */
+    barPadding?: number;
+    rx?: number;
+    /** Box plot accessors (BoxPlotChart). Raw `samples` wins over the precomputed five. */
+    low?: (datum: T, index: number) => number | null | undefined;
+    q1?: (datum: T, index: number) => number | null | undefined;
+    median?: (datum: T, index: number) => number | null | undefined;
+    q3?: (datum: T, index: number) => number | null | undefined;
+    high?: (datum: T, index: number) => number | null | undefined;
+    outliers?: (datum: T, index: number) => readonly number[] | undefined;
+    samples?: (datum: T, index: number) => readonly number[] | undefined;
+    whisker?: WhiskerMode;
+    whiskerK?: number;
+    boxPadding?: number;
+    /** Marker visibility: 'always' (all dots visible), 'hover' (dot at hovered x), 'none' (no markers). */
+    markers?: MarkerMode;
+    /** Symbol shape for point markers. */
+    symbol?: SymbolName;
+    /** Symbol area in px² (default 64 ≈ 4.5px radius circle). */
+    symbolSize?: number;
+    /** Draw value labels. */
+    labels?: boolean;
+}
+/** Chart-level series defaults — everything but data/name. */
+export type PlotOptions<T = unknown> = Omit<Partial<SeriesOptions<T>>, 'data' | 'name'>;
+export declare const SERIES_DEFAULTS: {
+    curve: CurveName;
+    strokeWidth: number;
+    fillOpacity: number;
+    barPadding: number;
+    rx: number;
+    markers: MarkerMode;
+    symbolSize: number;
+    labels: boolean;
+    whisker: WhiskerMode;
+    whiskerK: number;
+    boxPadding: number;
+};
+export type ResolvedSeries<T> = SeriesOptions<T> & typeof SERIES_DEFAULTS;
+/** chart defaults < plotOptions < series. (Per-point colorFor applies at render.) */
+export declare function resolveSeries<T>(plotOptions: PlotOptions<T> | undefined, series: SeriesOptions<T>): ResolvedSeries<T>;
+/** Axis prop for L2 charts: scale options + display options in one bag. */
+export interface SimpleAxisOptions extends AxisOptions {
+    title?: string;
+    ticks?: number;
+    format?: (value: XValue, index: number) => string;
+    rotate?: number;
+    /** false hides the axis entirely. */
+    visible?: boolean;
+}
+export interface SplitAxis {
+    scale: AxisOptions | undefined;
+    display: {
+        title?: string;
+        ticks?: number;
+        format?: (value: XValue, index: number) => string;
+        rotate?: number;
+    };
+    visible: boolean;
+}
+/** Separate what <Chart> needs (scale) from what <Axis> needs (display). */
+export declare function splitAxisOptions(options: SimpleAxisOptions | undefined): SplitAxis;
+export interface BandSpec {
+    axis?: 'x' | 'y';
+    from: XValue;
+    to: XValue;
+    color?: string;
+    label?: string;
+}
+export interface PlotLineSpec {
+    axis?: 'x' | 'y';
+    value: XValue;
+    color?: string;
+    dash?: string;
+    label?: string;
+}
+export interface TooltipSpec {
+    mode?: TooltipMode;
+    shared?: boolean;
+    formatX?: (x: XValue) => string;
+    formatY?: (y: number) => string;
+}
+export interface LegendSpec {
+    position?: 'top' | 'bottom';
+}

package/dist/core/options.js

@@ -0,0 +1,36 @@
+/**
+ * L2 simple-chart option types + resolution.
+ *
+ * The precedence chain, end to end (later wins):
+ *
+ *   SERIES_DEFAULTS  <  chart plotOptions  <  per-series options  <  per-point
+ *
+ * The first three layers resolve through mergeOptions in resolveSeries(); the
+ * per-point layer is `colorFor(datum, index)`, applied at render time by the
+ * marks (its result wins over the resolved series color).
+ */
+import { mergeOptions } from './merge.js';
+export const SERIES_DEFAULTS = {
+    curve: 'linear',
+    strokeWidth: 2,
+    fillOpacity: 0.2,
+    barPadding: 0.08,
+    rx: 0,
+    markers: 'hover',
+    symbolSize: 64,
+    labels: false,
+    whisker: 'tukey',
+    whiskerK: 1.5,
+    boxPadding: 0.15
+};
+/** chart defaults < plotOptions < series. (Per-point colorFor applies at render.) */
+export function resolveSeries(plotOptions, series) {
+    return mergeOptions(SERIES_DEFAULTS, plotOptions, series);
+}
+/** Separate what <Chart> needs (scale) from what <Axis> needs (display). */
+export function splitAxisOptions(options) {
+    if (!options)
+        return { scale: undefined, display: {}, visible: true };
+    const { title, ticks, format, rotate, visible, ...scale } = options;
+    return { scale, display: { title, ticks, format, rotate }, visible: visible !== false };
+}

package/dist/core/palette.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Styled mode: every color resolves from a CSS custom property.
+ * The hex literals below are the ONLY literal colors in the library, and they
+ * exist solely as var() fallbacks — consumers theme by defining --fc-series-N.
+ */
+export declare const DEFAULT_PALETTE: readonly string[];
+/** `var(--fc-series-N, fallback)` for a zero-based series index (wraps past 12). */
+export declare function seriesColorVar(index: number): string;

package/dist/core/palette.js

@@ -0,0 +1,24 @@
+/**
+ * Styled mode: every color resolves from a CSS custom property.
+ * The hex literals below are the ONLY literal colors in the library, and they
+ * exist solely as var() fallbacks — consumers theme by defining --fc-series-N.
+ */
+export const DEFAULT_PALETTE = [
+    '#4f46e5', // indigo
+    '#0ea5e9', // sky
+    '#10b981', // emerald
+    '#f59e0b', // amber
+    '#f43f5e', // rose
+    '#8b5cf6', // violet
+    '#14b8a6', // teal
+    '#f97316', // orange
+    '#84cc16', // lime
+    '#d946ef', // fuchsia
+    '#06b6d4', // cyan
+    '#64748b' // slate
+];
+/** `var(--fc-series-N, fallback)` for a zero-based series index (wraps past 12). */
+export function seriesColorVar(index) {
+    const slot = ((index % DEFAULT_PALETTE.length) + DEFAULT_PALETTE.length) % DEFAULT_PALETTE.length;
+    return `var(--fc-series-${slot + 1}, ${DEFAULT_PALETTE[slot]})`;
+}

package/dist/core/responsive.d.ts

@@ -0,0 +1,6 @@
+export interface ResponsiveRule<P = Record<string, unknown>> {
+    minWidth?: number;
+    maxWidth?: number;
+    options: Partial<P>;
+}
+export declare function applyResponsive<P extends object>(base: P, rules: readonly ResponsiveRule<P>[] | undefined, width: number): P;

package/dist/core/responsive.js

@@ -0,0 +1,19 @@
+/**
+ * Container-driven responsive rules for L2 charts: each rule's options are
+ * merged over the base props (precedence utility, later rules win) when the
+ * measured container width matches. Width 0 (SSR / unmeasured) applies none.
+ */
+import { mergeOptions } from './merge.js';
+export function applyResponsive(base, rules, width) {
+    if (!rules?.length || width <= 0)
+        return base;
+    let out = base;
+    for (const rule of rules) {
+        const matchesMax = rule.maxWidth == null || width <= rule.maxWidth;
+        const matchesMin = rule.minWidth == null || width >= rule.minWidth;
+        if (matchesMax && matchesMin) {
+            out = mergeOptions(out, rule.options);
+        }
+    }
+    return out;
+}

package/dist/core/scales.d.ts

@@ -0,0 +1,31 @@
+import type { ScaleBand, ScaleLinear, ScaleTime } from 'd3-scale';
+import type { XValue } from './normalize.js';
+export type ScaleKind = 'linear' | 'time' | 'band';
+export type AnyScale = ScaleLinear<number, number> | ScaleTime<number, number> | ScaleBand<string>;
+export type ScaleDomain = [number, number] | [Date, Date] | string[];
+export interface ScaleSpec {
+    kind: ScaleKind;
+    domain: ScaleDomain;
+    range: [number, number];
+    /** `true` (default) → d3 nice(); a number → nice(count) tick hint; `false` → exact domain. */
+    nice?: boolean | number;
+    /** Band scales only: inner padding ratio (default 0.1). */
+    bandPadding?: number;
+}
+export declare function createScale(spec: ScaleSpec): AnyScale;
+export declare function isBandScale(scale: AnyScale): scale is ScaleBand<string>;
+/**
+ * Map a value to a pixel position. Band scales position at the band CENTER
+ * (right for lines/points over categories). Unmappable values yield NaN —
+ * callers filter via d3-shape `defined()` or render guards.
+ */
+export declare function scalePos(scale: AnyScale, value: XValue): number;
+/** Tick values: d3 ticks for continuous scales, the full domain for band scales. */
+export declare function scaleTicks(scale: AnyScale, count?: number): XValue[];
+/** Default tick label formatter: d3's precision/locale-aware one when available. */
+export declare function scaleTickFormat(scale: AnyScale, count?: number): (value: XValue) => string;
+/**
+ * Invert a pixel position to the band category whose center is closest.
+ * Band scales have no native invert; this is the tooltip "band" mode lookup.
+ */
+export declare function bandInvert(scale: ScaleBand<string>, px: number): string | null;

package/dist/core/scales.js

@@ -0,0 +1,89 @@
+/**
+ * Scale factory + scale helpers. d3 does math only — it never touches the DOM.
+ * All scale-type branching lives here so components stay scale-agnostic.
+ */
+import { scaleBand, scaleLinear, scaleTime } from 'd3-scale';
+export function createScale(spec) {
+    const { kind, range } = spec;
+    if (kind === 'band') {
+        const padding = spec.bandPadding ?? 0.1;
+        return scaleBand()
+            .domain(spec.domain)
+            .range(range)
+            .paddingInner(padding)
+            .paddingOuter(padding / 2);
+    }
+    if (kind === 'time') {
+        const scale = scaleTime()
+            .domain(spec.domain)
+            .range(range);
+        if (spec.nice !== false) {
+            if (typeof spec.nice === 'number')
+                scale.nice(spec.nice);
+            else
+                scale.nice();
+        }
+        return scale;
+    }
+    const scale = scaleLinear()
+        .domain(spec.domain)
+        .range(range);
+    if (spec.nice !== false) {
+        if (typeof spec.nice === 'number')
+            scale.nice(spec.nice);
+        else
+            scale.nice();
+    }
+    return scale;
+}
+export function isBandScale(scale) {
+    return 'bandwidth' in scale;
+}
+/**
+ * Map a value to a pixel position. Band scales position at the band CENTER
+ * (right for lines/points over categories). Unmappable values yield NaN —
+ * callers filter via d3-shape `defined()` or render guards.
+ */
+export function scalePos(scale, value) {
+    if (isBandScale(scale)) {
+        const start = scale(String(value));
+        return start === undefined ? NaN : start + scale.bandwidth() / 2;
+    }
+    const input = value instanceof Date ? value : typeof value === 'number' ? value : NaN;
+    if (typeof input === 'number' && Number.isNaN(input))
+        return NaN;
+    const px = scale(input);
+    return px == null || Number.isNaN(px) ? NaN : px;
+}
+/** Tick values: d3 ticks for continuous scales, the full domain for band scales. */
+export function scaleTicks(scale, count = 6) {
+    if (isBandScale(scale))
+        return scale.domain();
+    return scale.ticks(count);
+}
+/** Default tick label formatter: d3's precision/locale-aware one when available. */
+export function scaleTickFormat(scale, count = 6) {
+    if (isBandScale(scale))
+        return (value) => String(value);
+    const format = scale.tickFormat(count);
+    return (value) => format(value);
+}
+/**
+ * Invert a pixel position to the band category whose center is closest.
+ * Band scales have no native invert; this is the tooltip "band" mode lookup.
+ */
+export function bandInvert(scale, px) {
+    let best = null;
+    let bestDistance = Infinity;
+    for (const category of scale.domain()) {
+        const start = scale(category);
+        if (start === undefined)
+            continue;
+        const distance = Math.abs(start + scale.bandwidth() / 2 - px);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = category;
+        }
+    }
+    return best;
+}