matterviz 0.4.1 → 0.4.3

package/dist/plot/core/fill-utils.js

@@ -1,8 +1,9 @@
 // Fill-between utility functions for ScatterPlot fill regions
 // Each fill edge is traced through its boundary's own points with the same curve the series line
-// uses (curveMonotoneX), so an unclipped fill edge coincides with the line it borders. When an
-// edge is clipped (x_range / partial overlap), the inserted endpoint shifts the neighboring
-// monotone tangent, so the clipped edge can deviate sub-pixel from the full series line.
+// uses (a series edge inherits the series' `line_style.curve`, default monotoneX), so an unclipped
+// fill edge coincides with the line it borders. When an edge is clipped (x_range / partial
+// overlap), inserted endpoints are evaluated on a monotone-cubic approximation: sub-pixel for
+// monotoneX/linear/step, but natural/basis/catmullRom edges can deviate more at the clip points.
 import { curveBasis, curveCardinal, curveCatmullRom, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, line, } from 'd3-shape';
 // Epsilon value for log scale clamping (to avoid log(0) = -Infinity)
 export const LOG_EPSILON = 1e-10;
@@ -145,6 +146,19 @@ const finite_points = (xs, ys) => clean_pts(Array.from({ length: Math.min(xs.len
     x: xs[idx],
     y: ys[idx],
 })));
+// Bridge the public LineCurve vocabulary (series `line_style.curve`) to FillCurveType names so
+// a series fill edge traces with the same curve as its rendered line. Default: monotoneX.
+const LINE_CURVE_TO_FILL = {
+    linear: `linear`,
+    monotone: `monotoneX`,
+    natural: `natural`,
+    step: `step`,
+    basis: `basis`,
+    'catmull-rom': `catmullRom`,
+};
+const line_curve_to_fill = (curve) => 
+// ?? monotoneX guards an unknown string from an untyped (Python/JSON) caller
+(curve ? LINE_CURVE_TO_FILL[curve] : undefined) ?? `monotoneX`;
 // Resolve a boundary to native points + curve in data coordinates. `companion` supplies x
 // positions for boundaries that don't define their own (constant/axis/function/data-without-x).
 export function resolve_boundary_points(boundary, series, domains, companion) {
@@ -157,15 +171,16 @@ export function resolve_boundary_points(boundary, series, domains, companion) {
         points: horizontal(span_xs, y),
         curve: `linear`,
     });
-    // series / function / data edges are traced with monotoneX (matches the series line)
-    const curved_edge = (points) => points.length > 0 ? { points, curve: `monotoneX` } : null;
+    // function / data edges trace with monotoneX by default; a series edge inherits the
+    // series' own line curve so the fill border coincides with the rendered line
+    const curved_edge = (points, curve = `monotoneX`) => (points.length > 0 ? { points, curve } : null);
     if (typeof boundary === `number`)
         return flat_edge(boundary);
     if (boundary.type === `series`) {
         const resolved = resolve_series_ref(boundary, series);
         if (!resolved)
             return null;
-        return curved_edge(finite_points(resolved.x, resolved.y));
+        return curved_edge(finite_points(resolved.x, resolved.y), line_curve_to_fill(resolved.line_style?.curve));
     }
     if (boundary.type === `constant`)
         return flat_edge(boundary.value);
@@ -345,6 +360,10 @@ const CURVE_MAP = {
     natural: curveNatural,
 };
 const get_curve = (curve_type) => CURVE_MAP[curve_type] ?? curveMonotoneX;
+// Resolve a public LineCurve (a series' `line_style.curve`) to its d3 CurveFactory. Single source
+// of truth shared by Line.svelte and PlotMarginals.svelte (composes the LineCurve -> FillCurveType
+// -> CurveFactory maps); unknown/undefined falls back to curveMonotoneX.
+export const line_curve_factory = (curve) => get_curve(line_curve_to_fill(curve));
 const trace = (points, curve_type) => line()
     .x((pt) => pt.x)
     .y((pt) => pt.y)
@@ -378,6 +397,9 @@ export function convert_error_band_to_fill_region(error_band, series, default_co
     return {
         id: error_band.id,
         label: error_band.label,
+        // band edges are data boundaries (default monotoneX); inherit the central series' line
+        // curve so the band traces with the same curve as the line it brackets
+        curve: line_curve_to_fill(resolved.line_style?.curve),
         upper: { type: `data`, x, values: y.map((val, idx) => val + upper_err[idx]) },
         lower: { type: `data`, x, values: y.map((val, idx) => val - lower_err[idx]) },
         fill: error_band.fill ?? default_color ?? `#4e79a7`,

package/dist/plot/core/index.d.ts

@@ -3,6 +3,7 @@ export * from './data-cleaning';
 export * from './fill-utils';
 export * from './interactions';
 export * from './layout';
+export * from './marginals';
 export * from './reference-line';
 export * from './scales';
 export * from './svg';

package/dist/plot/core/index.js

@@ -4,6 +4,7 @@ export * from './data-cleaning';
 export * from './fill-utils';
 export * from './interactions';
 export * from './layout';
+export * from './marginals';
 export * from './reference-line';
 export * from './scales';
 export * from './svg';

package/dist/plot/core/interactions.js

@@ -7,8 +7,6 @@ export function get_relative_coords(evt, element = evt.currentTarget) {
     if (!(element instanceof Element))
         return null;
     const box = element.getBoundingClientRect();
-    if (!box)
-        return null;
     return { x: evt.clientX - box.left, y: evt.clientY - box.top };
 }
 // Resolve a delegated event to the integer value of the nearest ancestor's data

package/dist/plot/core/layout.d.ts

@@ -5,14 +5,20 @@ export type Sides = {
     l?: number;
     r?: number;
 };
-export declare const LABEL_GAP_DEFAULT = 30;
+export declare const LABEL_GAP_DEFAULT = 20;
+export declare const DEFAULT_PLOT_PADDING: Required<Sides>;
 export declare function y2_axis_label_x(axis: AxisConfig, width: number, pad_r: number, max_tick_width: number): number;
 export declare const filter_padding: (padding: Partial<Sides> | undefined | null, defaults: Required<Sides>) => Required<Sides>;
 export declare function measure_text_width(text: string, font?: string): number;
-export declare function measure_full_footprint(el: HTMLElement): {
+type Size = {
     width: number;
     height: number;
 };
+type ElementFootprint = Size & {
+    offset_x: number;
+    offset_y: number;
+};
+export declare const full_footprint_or: (el: HTMLElement | null | undefined, fallback: Size) => ElementFootprint;
 export interface AutoPaddingConfig {
     padding: Partial<Sides>;
     default_padding: Required<Sides>;
@@ -30,6 +36,7 @@ export interface AutoPaddingConfig {
 export declare const measure_max_tick_width: (ticks: (string | number)[], format?: string) => number;
 export declare const TICK_LABEL_HEIGHT = 16;
 export declare const AXIS_LABEL_HEIGHT = 20;
+export declare const AXIS_TITLE_OFFSET: number;
 export declare const calc_auto_padding: ({ padding, default_padding, x2_axis, y_axis, y2_axis, label_gap, }: AutoPaddingConfig) => Required<Sides>;
 export declare function constrain_tooltip_position(cursor_x: number, cursor_y: number, tooltip_width: number, tooltip_height: number, viewport_width: number, viewport_height: number, options?: {
     offset?: number;
@@ -50,10 +57,7 @@ export declare const centered_rect: (center_x: number, top_y: number, width: num
 export declare const rect_within_rect: (rect: Rect, bounds: Rect) => boolean;
 export interface ElementPlacementConfig {
     plot_bounds: Rect;
-    element_size: {
-        width: number;
-        height: number;
-    };
+    element_size: Size;
     element?: HTMLElement | null;
     axis_clearance?: number;
     exclude_rects?: Rect[];
@@ -68,6 +72,10 @@ export interface ElementPlacementResult {
     y: number;
     score: number;
 }
+export declare const point_in_rect: (point: {
+    x: number;
+    y: number;
+}, rect: Rect) => boolean;
 export declare const rects_overlap: (r1: Rect, r2: Rect) => boolean;
 export declare function sample_series_obstacle_points(pixel_points: {
     x: number;
@@ -77,3 +85,4 @@ export declare function sample_series_obstacle_points(pixel_points: {
     y: number;
 }[];
 export declare function compute_element_placement(config: ElementPlacementConfig): ElementPlacementResult;
+export {};

package/dist/plot/core/layout.js

@@ -1,7 +1,10 @@
 import { format_value } from '../../labels';
 import { euclidean_dist } from '../../math';
 // Default gap between tick labels and axis labels
-export const LABEL_GAP_DEFAULT = 30;
+export const LABEL_GAP_DEFAULT = 20;
+// Default plot padding (px) reserved for axis ticks/labels, shared by
+// Histogram/BarPlot/BoxPlot/BinnedScatterPlot (ScatterPlot keeps its own bespoke default)
+export const DEFAULT_PLOT_PADDING = { t: 20, b: 60, l: 60, r: 20 };
 // X position for a right-side (y2) axis label: past the plot edge plus tick shift and
 // measured tick-label width (both zero when tick labels render inside the plot)
 export function y2_axis_label_x(axis, width, pad_r, max_tick_width) {
@@ -28,23 +31,35 @@ export function measure_text_width(text, font = `12px sans-serif`) {
     ctx.font = font;
     return ctx.measureText(text).width;
 }
-// Measure an element's full visual footprint, including descendants that overflow its
-// offset box. Colorbar tick labels are position:absolute outside the bar, so
-// offsetWidth/offsetHeight underestimate the space they actually occupy — which lets
-// auto-placement put the colorbar where its labels overlap the axes.
-export function measure_full_footprint(el) {
+function measure_full_footprint(el) {
     const root = el.getBoundingClientRect();
+    let left = root.left;
+    let top = root.top;
     let right = root.right;
     let bottom = root.bottom;
     for (const child of el.querySelectorAll(`*`)) {
         const rect = child.getBoundingClientRect();
         if (rect.width === 0 && rect.height === 0)
             continue;
+        left = Math.min(left, rect.left);
+        top = Math.min(top, rect.top);
         right = Math.max(right, rect.right);
         bottom = Math.max(bottom, rect.bottom);
     }
-    return { width: right - root.left, height: bottom - root.top };
+    return {
+        width: right - left,
+        height: bottom - top,
+        offset_x: left - root.left,
+        offset_y: top - root.top,
+    };
 }
+// Full footprint once the element is laid out, else `fallback` (offset dims read 0
+// before first render). NOT interchangeable with auto-place's measured_footprint:
+// that returns the offset box, which underestimates elements with overflowing
+// absolutely-positioned descendants like colorbar tick labels.
+export const full_footprint_or = (el, fallback) => el?.offsetWidth && el?.offsetHeight
+    ? measure_full_footprint(el)
+    : { ...fallback, offset_x: 0, offset_y: 0 };
 // Measure the widest formatted tick label. Used for auto-padding and label placement.
 export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0
     ? 0
@@ -56,22 +71,28 @@ export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0
 export const TICK_LABEL_HEIGHT = 16;
 // Estimated height of an axis label (font-size ~14px + margin)
 export const AXIS_LABEL_HEIGHT = 20;
+// Distance from an x/x2 axis baseline to the title center.
+export const AXIS_TITLE_OFFSET = TICK_LABEL_HEIGHT + LABEL_GAP_DEFAULT;
 export const calc_auto_padding = ({ padding, default_padding, x2_axis = {}, y_axis = {}, y2_axis = {}, label_gap = LABEL_GAP_DEFAULT, }) => {
-    const x2_ticks = x2_axis.tick_values ?? [];
-    const y_ticks = y_axis.tick_values ?? [];
-    const y_format = y_axis.format ?? ``;
-    const y2_ticks = y2_axis.tick_values ?? [];
-    const y2_format = y2_axis.format ?? ``;
+    // Padding for a vertical-axis side (y/y2): when ticks render, reserve widest tick label + gap +
+    // the rotated axis-title width (mirrors the `t` branch's AXIS_LABEL_HEIGHT) so a wide tick label
+    // can't overlap the title. With no tick labels (e.g. no y2 series) reserve nothing extra.
+    const side_pad = (axis, default_side) => {
+        const ticks = axis.tick_values ?? [];
+        if (ticks.length === 0)
+            return default_side;
+        return Math.max(default_side, measure_max_tick_width(ticks, axis.format ?? ``) +
+            label_gap +
+            (axis.label ? AXIS_LABEL_HEIGHT : 0));
+    };
     return {
         t: padding.t ??
-            (x2_ticks.length > 0
+            ((x2_axis.tick_values ?? []).length > 0
                 ? Math.max(default_padding.t, TICK_LABEL_HEIGHT + label_gap + (x2_axis.label ? AXIS_LABEL_HEIGHT : 0))
                 : default_padding.t),
         b: padding.b ?? default_padding.b,
-        l: padding.l ??
-            Math.max(default_padding.l, measure_max_tick_width(y_ticks, y_format) + label_gap),
-        r: padding.r ??
-            Math.max(default_padding.r, measure_max_tick_width(y2_ticks, y2_format) + label_gap),
+        l: padding.l ?? side_pad(y_axis, default_padding.l),
+        r: padding.r ?? side_pad(y2_axis, default_padding.r),
     };
 };
 // Constrain tooltip position within bounds, flipping to opposite side if overflow
@@ -139,7 +160,7 @@ const DISTANCE_WEIGHT = 0.001;
 const CORNER_WEIGHT = 5.0;
 const MAX_SAMPLE_POINTS = 500;
 // Check if a point is inside a rectangle
-const point_in_rect = (point, rect) => point.x >= rect.x &&
+export const point_in_rect = (point, rect) => point.x >= rect.x &&
     point.x <= rect.x + rect.width &&
     point.y >= rect.y &&
     point.y <= rect.y + rect.height;
@@ -186,14 +207,16 @@ export function compute_element_placement(config) {
     // Measure the element's full footprint (incl. descendants that overflow its box,
     // such as colorbar tick labels) once it's laid out; fall back to element_size before
     // first render. Centralizing this keeps every plot's auto-placement overlap-free.
-    const { width: elem_width, height: elem_height } = element?.offsetWidth && element?.offsetHeight
-        ? measure_full_footprint(element)
-        : element_size;
+    const { width: elem_width, height: elem_height, offset_x, offset_y, } = full_footprint_or(element, element_size);
     // Calculate valid placement region (plot bounds minus axis clearance)
-    const valid_x_min = plot_bounds.x + axis_clearance;
-    const valid_y_min = plot_bounds.y + axis_clearance;
-    const valid_x_max = plot_bounds.x + plot_bounds.width - axis_clearance - elem_width;
-    const valid_y_max = plot_bounds.y + plot_bounds.height - axis_clearance - elem_height;
+    const plot_left = plot_bounds.x + axis_clearance;
+    const plot_right = plot_bounds.x + plot_bounds.width - axis_clearance;
+    const plot_top = plot_bounds.y + axis_clearance;
+    const plot_bottom = plot_bounds.y + plot_bounds.height - axis_clearance;
+    const valid_x_min = plot_left - offset_x;
+    const valid_y_min = plot_top - offset_y;
+    const valid_x_max = plot_right - offset_x - elem_width;
+    const valid_y_max = plot_bottom - offset_y - elem_height;
     // Handle case where element is too large for the valid region
     const effective_x_min = Math.min(valid_x_min, valid_x_max);
     const effective_x_max = Math.max(valid_x_min, valid_x_max);
@@ -216,18 +239,14 @@ export function compute_element_placement(config) {
         ? (effective_y_max - effective_y_min) / (grid_resolution - 1)
         : 0;
     // Precompute plot corners (constant across all candidates)
-    const plot_left = plot_bounds.x + axis_clearance;
-    const plot_right = plot_bounds.x + plot_bounds.width - axis_clearance;
-    const plot_top = plot_bounds.y + axis_clearance;
-    const plot_bottom = plot_bounds.y + plot_bounds.height - axis_clearance;
     const max_corner_dist = euclidean_dist([plot_left, plot_top], [plot_right, plot_bottom]);
     for (let grid_x = 0; grid_x < grid_resolution; grid_x++) {
         for (let grid_y = 0; grid_y < grid_resolution; grid_y++) {
             const cand_x = effective_x_min + grid_x * x_step;
             const cand_y = effective_y_min + grid_y * y_step;
             const cand_rect = {
-                x: cand_x,
-                y: cand_y,
+                x: cand_x + offset_x,
+                y: cand_y + offset_y,
                 width: elem_width,
                 height: elem_height,
             };
@@ -241,8 +260,8 @@ export function compute_element_placement(config) {
             // Count points overlapping this candidate position
             let overlap_count = 0;
             let min_distance_sq = Infinity;
-            const center_x = cand_x + elem_width / 2;
-            const center_y = cand_y + elem_height / 2;
+            const center_x = cand_rect.x + elem_width / 2;
+            const center_y = cand_rect.y + elem_height / 2;
             for (const point of sampled_points) {
                 if (point_in_rect(point, cand_rect)) {
                     overlap_count++;
@@ -262,12 +281,12 @@ export function compute_element_placement(config) {
             // Corner preference: use element's actual corner (not center) for distance
             // This ensures a wide element at the left edge gets proper corner credit
             // (measured footprint, same as cand_rect — not the element_size fallback)
-            const elem_right = cand_x + elem_width;
-            const elem_bottom = cand_y + elem_height;
+            const elem_right = cand_rect.x + elem_width;
+            const elem_bottom = cand_rect.y + elem_height;
             // Distance from element's matching corner to each plot corner
-            const min_corner_dist = Math.min(euclidean_dist([cand_x, cand_y], [plot_left, plot_top]), // top-left
-            euclidean_dist([elem_right, cand_y], [plot_right, plot_top]), // top-right
-            euclidean_dist([cand_x, elem_bottom], [plot_left, plot_bottom]), // bottom-left
+            const min_corner_dist = Math.min(euclidean_dist([cand_rect.x, cand_rect.y], [plot_left, plot_top]), // top-left
+            euclidean_dist([elem_right, cand_rect.y], [plot_right, plot_top]), // top-right
+            euclidean_dist([cand_rect.x, elem_bottom], [plot_left, plot_bottom]), // bottom-left
             euclidean_dist([elem_right, elem_bottom], [plot_right, plot_bottom]));
             // Higher bonus for positions closer to corners (0 = at corner, 1 = far from all)
             const corner_bonus = max_corner_dist > 0 ? (1 - min_corner_dist / max_corner_dist) * CORNER_WEIGHT : 0;

package/dist/plot/core/marginals.d.ts

@@ -0,0 +1,170 @@
+import type { Vec2 } from '../../math';
+import type { Rect, Sides } from './layout';
+import type { LineCurve, ScaleType } from './types';
+import type { Snippet } from 'svelte';
+export type MarginalSide = `top` | `bottom` | `left` | `right`;
+export type MarginalType = `histogram` | `kde` | `cdf` | `rug`;
+export type MarginalPlacement = `auto` | `flush` | `outer`;
+export type MarginalNormalize = `count` | `density` | `probability`;
+export type MarginalAxisBinding = `x1` | `x2` | `y1` | `y2`;
+export declare const MARGINAL_SIDES: readonly ["top", "bottom", "left", "right"];
+export type MarginalCurve = {
+    kind: `bars`;
+    bins: {
+        pos0: number;
+        pos1: number;
+        value: number;
+    }[];
+    max: number;
+} | {
+    kind: `line`;
+    points: {
+        pos: number;
+        value: number;
+    }[];
+    max: number;
+} | {
+    kind: `rug`;
+    positions: number[];
+};
+export interface MarginalComputeContext {
+    config: ResolvedMarginalConfig;
+    side: MarginalSide;
+    positional_range: Vec2;
+    scale_type: ScaleType;
+}
+export interface MarginalConfig {
+    type?: MarginalType;
+    size?: number;
+    gap?: number;
+    placement?: MarginalPlacement;
+    axis?: MarginalAxisBinding;
+    bins?: number;
+    bandwidth?: number | `silverman` | `scott`;
+    normalize?: MarginalNormalize;
+    per_series?: boolean;
+    color?: string;
+    fill?: string;
+    fill_opacity?: number;
+    stroke?: string;
+    stroke_width?: number;
+    opacity?: number;
+    curve?: LineCurve;
+    value_range?: Vec2;
+    value_axis?: boolean;
+    label?: string;
+    data?: readonly number[] | ((ctx: MarginalComputeContext) => readonly number[]);
+    reduce?: (values: number[], weights: number[] | undefined, ctx: MarginalComputeContext) => MarginalCurve;
+    snippet?: Snippet<[MarginalRenderContext]>;
+    hover?: boolean;
+    tooltip?: Snippet<[MarginalHover]>;
+    class?: string;
+    style?: string;
+}
+export type ResolvedMarginalConfig = MarginalConfig & {
+    type: MarginalType;
+    size: number;
+    gap: number;
+    placement: MarginalPlacement;
+    per_series: boolean;
+    bins: number;
+    bandwidth: number | `silverman` | `scott`;
+    stroke_width: number;
+    opacity: number;
+    value_axis: boolean;
+};
+export type MarginalSideInput = boolean | MarginalType | MarginalConfig;
+export type MarginalsProp = boolean | MarginalType | Partial<Record<MarginalSide, MarginalSideInput>>;
+export type ResolvedMarginals = Record<MarginalSide, ResolvedMarginalConfig | null>;
+export interface MarginalSeriesInput {
+    x?: ArrayLike<number>;
+    y?: ArrayLike<number>;
+    weight?: ArrayLike<number>;
+    color: string;
+    label?: string;
+    visible?: boolean;
+    x_axis?: `x1` | `x2`;
+    y_axis?: `y1` | `y2`;
+}
+export interface MarginalSeriesCurve {
+    series_idx: number;
+    color: string;
+    label?: string;
+    curve: MarginalCurve;
+}
+export type ScaleFn = (value: number) => number;
+export interface MarginalAxis {
+    scale: ScaleFn;
+    range: Vec2;
+    scale_type?: ScaleType;
+    format?: string;
+    tick_label?: (value: number) => string | undefined;
+    label?: string;
+}
+export type MarginalAxes = {
+    x1: MarginalAxis;
+    x2?: MarginalAxis;
+    y1: MarginalAxis;
+    y2?: MarginalAxis;
+};
+export declare const marginal_axis: (scale: ScaleFn, range: Vec2, axis: {
+    scale_type?: ScaleType;
+    format?: string;
+    label?: string;
+}, tick_label?: (value: number) => string | undefined) => MarginalAxis;
+export interface MarginalRenderContext extends MarginalComputeContext {
+    rect: Rect;
+    positional_scale: ScaleFn;
+    value_scale: ScaleFn;
+    baseline: number;
+    curves: MarginalSeriesCurve[];
+    series: MarginalSeriesInput[];
+    format?: string;
+    tick_label?: (value: number) => string | undefined;
+    axis_title?: string;
+}
+export declare const MARGINAL_HIT_TOLERANCE_PX = 10;
+export interface MarginalHover {
+    side: MarginalSide;
+    x: number;
+    y: number;
+    color: string;
+    label?: string;
+    kind: MarginalCurve[`kind`];
+    pos: number;
+    pos0?: number;
+    pos1?: number;
+    value?: number;
+    config: ResolvedMarginalConfig;
+    scale_type: ScaleType;
+    format?: string;
+    pos_label?: string;
+    axis_title?: string;
+}
+export declare function marginal_hit(ctx: MarginalRenderContext, px: number, py: number): MarginalHover | null;
+export declare const MARGINAL_DEFAULTS: {
+    type: MarginalType;
+    size: number;
+    gap: number;
+    placement: MarginalPlacement;
+    per_series: boolean;
+    bins: number;
+    bandwidth: "silverman";
+    stroke_width: number;
+    opacity: number;
+    value_axis: boolean;
+};
+export declare function normalize_marginals(prop: MarginalsProp | undefined, default_sides?: Partial<Record<MarginalSide, MarginalSideInput>>): ResolvedMarginals;
+export declare function reserve_marginal_pad(resolved: ResolvedMarginals): Required<Sides>;
+export declare const add_sides: (a: Required<Sides>, b: Required<Sides>) => Required<Sides>;
+export declare const default_axis_for_side: (side: MarginalSide) => MarginalAxisBinding;
+export declare const marginal_axis_presence: (top: boolean, right: boolean) => Record<MarginalSide, boolean>;
+export declare function marginal_strip_rect(side: MarginalSide, pad: Required<Sides>, width: number, height: number, config: ResolvedMarginalConfig, has_axis: boolean): Rect;
+export declare function marginal_value_scale(side: MarginalSide, rect: Rect, domain: Vec2): {
+    scale: (value: number) => number;
+    baseline: number;
+};
+export declare function compute_marginal_curve(positions: ArrayLike<number>, weights: ArrayLike<number> | undefined, config: ResolvedMarginalConfig, positional_range: Vec2, scale_type: ScaleType): MarginalCurve;
+export declare const curves_max: (curves: MarginalCurve[]) => number;
+export declare const default_marginal_label: (config: ResolvedMarginalConfig) => string;
+export declare const marginal_value_format: (config: ResolvedMarginalConfig) => string;