@fundar/data-chart-telling 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/).
 
+## [1.16.0] - 2026-11-04
+
+### Fixed
+
+- A timeline tweened with `interpolate` is at its last step once `progress` comes within `timeline.snap` (default `1e-4`, a ten-thousandth of the span; `0` turns it off) of it. A scrubber that stops a hair short of `1` - a scrolled step ends at `0.97` - drew the line all the way to the end with its easing, but left out the last row: its dot, and a marker like a `delta` placed on it.
+
+## [1.15.0] - 2026-11-04
+
+### Fixed
+
+- A bar plot's value labels follow the bars that go below zero (or left of it): `'outside'` puts a label beyond its bar's tip on that side - to the left of a horizontal bar, under a vertical one - and the plot's margins make room for it. On a horizontal bar `'start'` is its left end and `'end'` its right one, both inside, and `'middle'` is its centre (it sat on the tip); a vertical bar's anchors are as they were.
+
+### Changed
+
+- On a line, the piece that joins two runs of a series is drawn as the first area segment that covers both of its ends - so a dashed projection that starts at the last observed year dashes the piece leaving that year, even where a faded range that ends there owns the point. It was always the catch-all's stroke, which left a solid piece at the start of the projection. A piece no area covers both ends of keeps the catch-all's stroke.
+
 ## [1.14.0] - 2026-11-04
 
 ### Added

package/dist/configuration/config.svelte.js

@@ -184,6 +184,7 @@ export const DEFAULT_CONFIG = {
         activeColor: '#4e79a7',
         thickness: 60,
         gap: '12px',
+        snap: 1e-4,
         rule: {
             fontSize: 12,
             activeFontSize: 20,

package/dist/layout/styles/ValueLabels.d.ts

@@ -59,8 +59,11 @@ export declare class ValueLabels {
         x?: number;
         y?: number;
     }, edges: MarginSide[]): EdgeBox;
-    /** Each series' value farthest from zero, read on `valueAxis` - the widest label it can show. */
-    extremes<S extends Series<any>>(series: S[], valueAxis?: 'x' | 'y'): {
+    /**
+     * Each series' value farthest from zero, read on `valueAxis` - the widest label it can show. With `'both'`,
+     * the farthest above zero and the farthest below it, whichever the series has.
+     */
+    extremes<S extends Series<any>>(series: S[], valueAxis?: 'x' | 'y', sides?: 'farthest' | 'both'): {
         series: S;
         value: number;
     }[];

package/dist/layout/styles/ValueLabels.js

@@ -88,21 +88,36 @@ export class ValueLabels {
         const box = this.textBox(text).beside({ x: at.x ?? 0, y: at.y ?? 0 }, side);
         return { box, edges };
     }
-    /** Each series' value farthest from zero, read on `valueAxis` - the widest label it can show. */
+    /**
+     * Each series' value farthest from zero, read on `valueAxis` - the widest label it can show. With `'both'`,
+     * the farthest above zero and the farthest below it, whichever the series has.
+     */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    extremes(series, valueAxis = 'y') {
+    extremes(series, valueAxis = 'y', sides = 'farthest') {
         return series.flatMap((s) => {
             const accessor = s[valueAxis];
             if (accessor === undefined)
                 return [];
             const y = resolveAccessor(accessor);
             let extreme;
+            let lowest;
+            let highest;
             for (const d of s.data) {
                 const v = Number(y(d));
-                if (!Number.isNaN(v) && (extreme === undefined || Math.abs(v) > Math.abs(extreme)))
+                if (Number.isNaN(v))
+                    continue;
+                if (extreme === undefined || Math.abs(v) > Math.abs(extreme))
                     extreme = v;
+                if (v < 0 && (lowest === undefined || v < lowest))
+                    lowest = v;
+                if (v >= 0 && (highest === undefined || v > highest))
+                    highest = v;
             }
-            return extreme === undefined ? [] : [{ series: s, value: extreme }];
+            if (extreme === undefined)
+                return [];
+            if (sides === 'farthest')
+                return [{ series: s, value: extreme }];
+            return [lowest, highest].flatMap((value) => value === undefined ? [] : [{ series: s, value }]);
         });
     }
     /**

package/dist/layout/timeline/TimelineLayout.svelte

@@ -2,6 +2,7 @@
 	import { untrack } from 'svelte';
 	import { resolveAccessor } from '../../utils/accessors';
 	import TimelineFrame from './TimelineFrame.svelte';
+	import { getConfiguration } from '../../configuration/config.svelte';
 	import { TimelineSteps } from './TimelineSteps';
 	import { TimelineTime } from './TimelineTime';
 	import { Interpolation } from '../../utils/Interpolation';
@@ -82,7 +83,9 @@
 	const segmentEasingFn = $derived(Interpolation.buildEasing(interpolate?.segmentEasing));
 
 	/** Continuous scrub position across the full step domain - only meaningful when `interpolate` is set. */
-	const currentTime = $derived(steps.timeAt(progress, progressEasingFn));
+	const currentTime = $derived(
+		steps.timeAt(progress, progressEasingFn, getConfiguration().timeline.snap)
+	);
 
 	const selectedValue = $derived(
 		(interpolate ? steps.nearest(currentTime) : steps.at(progress)) ?? 0

package/dist/layout/timeline/TimelineSteps.d.ts

@@ -17,8 +17,12 @@ export declare class TimelineSteps {
     get domain(): TimeValue[];
     /** The step a scrubber `progress` snaps to, or `undefined` without steps. */
     at(progress: number): TimeValue | undefined;
-    /** The continuous time `progress` is at across the steps, eased - `0` without steps. */
-    timeAt(progress: number, easing: EasingFn): number;
+    /**
+     * The continuous time `progress` is at across the steps, eased - `0` without steps. Within `snap` (a fraction
+     * of the span) of the last step it is at it: a scrubber that stops a hair short of `1` (a scrolled step's
+     * last position, say) still shows everything, with an eased tail that long gone to the end.
+     */
+    timeAt(progress: number, easing: EasingFn, snap?: number): number;
     /** The step closest to `time`, or `undefined` without steps. */
     nearest(time: number): TimeValue | undefined;
 }

package/dist/layout/timeline/TimelineSteps.js

@@ -34,12 +34,18 @@ export class TimelineSteps {
         const index = Math.round(progress * (values.length - 1));
         return values[Math.min(values.length - 1, Math.max(0, index))];
     }
-    /** The continuous time `progress` is at across the steps, eased - `0` without steps. */
-    timeAt(progress, easing) {
+    /**
+     * The continuous time `progress` is at across the steps, eased - `0` without steps. Within `snap` (a fraction
+     * of the span) of the last step it is at it: a scrubber that stops a hair short of `1` (a scrolled step's
+     * last position, say) still shows everything, with an eased tail that long gone to the end.
+     */
+    timeAt(progress, easing, snap = 0) {
         const { first, last } = this;
         if (first === undefined || last === undefined)
             return 0;
-        return first + (last - first) * easing(progress);
+        const span = last - first;
+        const time = first + span * easing(progress);
+        return last - time < span * snap ? last : time;
     }
     /** The step closest to `time`, or `undefined` without steps. */
     nearest(time) {

package/dist/plots/ranking/bar/defaults.js

@@ -68,15 +68,25 @@ export function buildBarDefaults() {
                     if (ProcessedPositions.span(state.processedData, axis).stacked)
                         return [];
                     if (!state.axes?.isHorizontal) {
-                        const at = { y: -labels.offset('y') };
-                        return [labels.edgeBox('0', { x: 'middle', y: 'before' }, at, ['top'])];
+                        const offset = labels.offset('y');
+                        const boxes = [
+                            labels.edgeBox('0', { x: 'middle', y: 'before' }, { y: -offset }, ['top'])
+                        ];
+                        // A bar below zero has its label under its tip.
+                        const hasNegative = labels
+                            .extremes(state.resolvedSeries ?? [], PlotAxes.valueOf(state), 'both')
+                            .some(({ value }) => value < 0);
+                        if (hasNegative)
+                            boxes.push(labels.edgeBox('0', { x: 'middle', y: 'after' }, { y: offset }, ['bottom']));
+                        return boxes;
                     }
-                    const at = { x: labels.offset('x') };
+                    // A bar below zero reaches out to the left, with its label turned that way.
+                    const offset = labels.offset('x');
                     return labels
-                        .extremes(state.resolvedSeries ?? [], PlotAxes.valueOf(state))
-                        .map(({ series, value }) => labels.edgeBox(labels.format(value, series.name), { x: 'after', y: 'middle' }, at, [
-                        'right'
-                    ]));
+                        .extremes(state.resolvedSeries ?? [], PlotAxes.valueOf(state), 'both')
+                        .map(({ series, value }) => value < 0
+                        ? labels.edgeBox(labels.format(value, series.name), { x: 'before', y: 'middle' }, { x: -offset }, ['left'])
+                        : labels.edgeBox(labels.format(value, series.name), { x: 'after', y: 'middle' }, { x: offset }, ['right']));
                 }
             }
         },

package/dist/plots/ranking/bar/markers.js

@@ -82,60 +82,59 @@ export function buildValueLabels(labels, state, ctx) {
     const geometry = buildBarGeometry(state, ctx.cfg.bar.seriesPadding);
     const { font, anchor, format } = labels;
     const valueOf = ValueLabels.valueOf(state);
-    const top = (d) => geometry.spanOf(d)?.[1] ?? 0;
-    const position = geometry.stacked
-        ? (d) => {
-            const [from, to] = geometry.spanOf(d) ?? [0, 0];
-            return (from + to) / 2;
-        }
-        : anchor === 'middle' && !isHorizontal
-            ? (d) => top(d) / 2
-            : anchor === 'end'
-                ? () => 0
-                : top;
-    // Outward from the bar's top along the value axis: up for a vertical bar, right for a horizontal one.
-    const outward = anchor === 'outside' ? 6 : anchor === 'start' ? -4 : anchor === 'end' ? 4 : 0;
-    const textAnchor = labels.textAnchor ??
-        (isHorizontal
-            ? anchor === 'outside' || anchor === 'end'
-                ? 'start'
-                : anchor === 'start'
-                    ? 'end'
-                    : 'middle'
-            : 'middle');
-    const lineAnchor = font?.lineAnchor ??
-        (isHorizontal
-            ? 'middle'
-            : anchor === 'outside' || anchor === 'end'
-                ? 'bottom'
-                : anchor === 'start'
-                    ? 'top'
-                    : 'middle');
+    const spanOf = (d) => geometry.spanOf(d) ?? [0, 0];
+    const lowOf = (d) => Math.min(...spanOf(d));
+    const highOf = (d) => Math.max(...spanOf(d));
+    const below = (d) => Number(valueOf(d)) < 0;
+    const place = (negative) => {
+        const mid = (d) => (lowOf(d) + highOf(d)) / 2;
+        if (geometry.stacked)
+            return { at: mid, side: 0 };
+        if (anchor === 'middle')
+            return { at: mid, side: 0 };
+        if (anchor === 'outside')
+            return isHorizontal
+                ? { at: negative ? lowOf : highOf, side: negative ? -1 : 1 }
+                : { at: negative ? lowOf : highOf, side: negative ? 1 : -1 };
+        if (anchor === 'start')
+            return isHorizontal ? { at: lowOf, side: 1 } : { at: highOf, side: 1 };
+        return isHorizontal ? { at: highOf, side: -1 } : { at: lowOf, side: -1 };
+    };
+    const gap = anchor === 'outside' ? 6 : 4;
     const labelled = processedData.data.filter((d) => d[GAP_VALUE] === undefined && geometry.spanOf(d) !== undefined);
     return (state.resolvedSeries ?? []).flatMap((s) => {
-        const data = labelled.filter((d) => d[SERIES_ID_KEY] === seriesIdOf(s));
-        if (data.length === 0)
-            return [];
-        return [
-            {
-                type: 'text',
-                data,
-                ...(isHorizontal
-                    ? { x: position, y: geometry.categoryOf }
-                    : { x: geometry.categoryOf, y: position }),
-                bandSlice: geometry.sliceOf(s.name),
-                text: (d) => format(Number(valueOf(d)), s.name, d),
-                styles: {
-                    ...font,
-                    fill: font?.fill ?? ctx.cfg.axis.color,
-                    fontSize: font?.fontSize ?? 12,
-                    dx: font?.dx ?? (isHorizontal ? outward : 0),
-                    dy: font?.dy ?? (isHorizontal ? 0 : -outward),
-                    textAnchor,
-                    lineAnchor
+        const own = labelled.filter((d) => d[SERIES_ID_KEY] === seriesIdOf(s));
+        // Only a label beyond the tip turns with the sign of its value.
+        const turns = !geometry.stacked && anchor === 'outside';
+        return (turns ? [false, true] : [false]).flatMap((negative) => {
+            const data = turns ? own.filter((d) => below(d) === negative) : own;
+            if (data.length === 0)
+                return [];
+            const { at, side } = place(negative);
+            // A horizontal label reads away from its point to `side`; a vertical one sits on the far side of it.
+            const textAnchor = labels.textAnchor ??
+                (isHorizontal ? (side === 1 ? 'start' : side === -1 ? 'end' : 'middle') : 'middle');
+            const lineAnchor = font?.lineAnchor ??
+                (isHorizontal ? 'middle' : side === 1 ? 'top' : side === -1 ? 'bottom' : 'middle');
+            return [
+                {
+                    type: 'text',
+                    data,
+                    ...(isHorizontal ? { x: at, y: geometry.categoryOf } : { x: geometry.categoryOf, y: at }),
+                    bandSlice: geometry.sliceOf(s.name),
+                    text: (d) => format(Number(valueOf(d)), s.name, d),
+                    styles: {
+                        ...font,
+                        fill: font?.fill ?? ctx.cfg.axis.color,
+                        fontSize: font?.fontSize ?? 12,
+                        dx: font?.dx ?? (isHorizontal ? side * gap : 0),
+                        dy: font?.dy ?? (isHorizontal ? 0 : side * gap),
+                        textAnchor,
+                        lineAnchor
+                    }
                 }
-            }
-        ];
+            ];
+        });
     });
 }
 /**

package/dist/plots/utils/segments.js

@@ -128,11 +128,34 @@ function resolveSeriesSegments(series, segmentsOfSeries, connect, base) {
     // the default palette color when the user has set a baseline via catch-all.
     // Dots are excluded to avoid duplicate marks at the shared boundary points.
     const catchAll = segs.find((s) => !s.areas || s.areas.length === 0);
-    const connectorStyle = (() => {
-        const rest = { ...(catchAll?.styles ?? baseStyle) };
+    const withoutDots = (style) => {
+        const rest = { ...style };
         delete rest.dot;
         return rest;
-    })();
+    };
+    const connectorStyle = withoutDots((catchAll?.styles ?? baseStyle));
+    // A segment's style as its own run is drawn with: an area segment over the catch-all's.
+    const styleOf = (idx) => {
+        const seg = segs[idx];
+        const own = seg.styles ?? {};
+        const isAreaSpecific = seg.areas != null && seg.areas.length > 0;
+        return isAreaSpecific && catchAll?.styles
+            ? merge(catchAll.styles, own)
+            : own;
+    };
+    // The line that joins two runs is drawn as the first area segment that covers both of its ends - a dashed
+    // projection that starts at the last observed year also dashes the piece leaving it, even where a faded
+    // range that ends there owns that year's point. Where none does, it is the catch-all's.
+    const covers = (idx, row) => {
+        const areas = segs[idx].areas;
+        return (areas != null &&
+            areas.length > 0 &&
+            areas.some((area) => areaMatchesXY(getX(row), getY(row), area)));
+    };
+    const joining = (from, to) => {
+        const covering = evalOrder.find(({ i }) => covers(i, from) && covers(i, to));
+        return covering ? withoutDots(styleOf(covering.i)) : connectorStyle;
+    };
     const defaultVisual = [];
     const connectors = [];
     const userVisual = [];
@@ -161,7 +184,7 @@ function resolveSeriesSegments(series, segmentsOfSeries, connect, base) {
                 if (r < runs.length - 1) {
                     connectors.push({
                         data: [last, runs[r + 1].data[0]],
-                        styles: connectorStyle,
+                        styles: joining(last, runs[r + 1].data[0]),
                         scales: undefined
                     });
                 }
@@ -188,7 +211,7 @@ function resolveSeriesSegments(series, segmentsOfSeries, connect, base) {
             if (connect && nextRun && nextRun.segIdx !== -1) {
                 connectors.push({
                     data: [run.data[run.data.length - 1], nextRun.data[0]],
-                    styles: connectorStyle,
+                    styles: joining(run.data[run.data.length - 1], nextRun.data[0]),
                     scales: undefined
                 });
             }

package/dist/types/configuration/styling.d.ts

@@ -271,6 +271,12 @@ export type PlotStylesConfig = {
         thickness: number;
         /** Space between a plot (or a composition's panels) and its timeline, as a CSS length. */
         gap: string;
+        /**
+         * How close to the first or last step a tweened timeline counts as being at it, as a fraction of its span.
+         * A scrubber that stops a hair short of `0` or `1` - a scrolled step ends at `0.97`, whose eased time is a
+         * hair short of the end - still shows the last row, and a marker placed on it. `0` turns it off.
+         */
+        snap: number;
         /** The `'rule'` timeline beside a plot: a line with its steps written along it. */
         rule: {
             /** Font size of the steps, in px. */

package/dist/types/plots/constants.d.ts

@@ -8,6 +8,11 @@
  *   of a pyramid bar from zero, right of a line's last point).
  * - `'middle'` - centred on the mark.
  * - `'end'` - at the baseline/zero end of the mark.
+ *
+ * On a bar plot the anchors read as the bars are drawn, whatever the sign of the value: `'outside'` is
+ * beyond the tip (left of a horizontal bar below zero, under a vertical one), `'start'` the left end of a
+ * horizontal bar or the top end of a vertical one, `'end'` the right or bottom end, both inside, and
+ * `'middle'` the centre.
  */
 export type ValueAnchor = 'outside' | 'start' | 'middle' | 'end';
 /**

package/docs/styles-and-segments.md

@@ -46,18 +46,18 @@
 
 ![End-of-line value labels](images/value-labels.png)
 
-| Field                                         | Meaning                                                                                                                                                                                                                   |
-| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `show`                                        | Draws the labels. Off by default, except on a heatmap                                                                                                                                                                     |
-| `anchor`                                      | `'outside'`, `'start'`, `'middle'`, `'end'` - where a label sits on its mark                                                                                                                                              |
-| `select`                                      | Which row of each group is labelled: `'first'`, `'last'`, `'min'`, `'max'`, or a list of them. A group is a series on a line or area plot (default `'last'`), a category on the plots that join dots (default: every dot) |
-| `series`                                      | Labels only these series, by name                                                                                                                                                                                         |
-| `color`                                       | `'series'` writes each label in its series' color; any other CSS color writes them all in it (`fontStyle.fill` wins)                                                                                                      |
-| `decimals`, `prefix`, `suffix`, `signDisplay` | How the value reads, over `numbers.decimals` ([Number format](theming.md#number-format)); `format` replaces them                                                                                                          |
-| `format`                                      | `(value, seriesName, row) => string`; `row` is the labelled row, for its other fields                                                                                                                                     |
-| `hoverIsolate`                                | Hovering a label dims every other series                                                                                                                                                                                  |
-| `fontStyle`                                   | Text style: `fontSize`, `fill`, `dx`, `dy`, `textAnchor`, `lineAnchor`, `rotate`, `class`, ... Overrides the anchor's placement field by field                                                                            |
-| `strokeStyle`                                 | Style of the connector lines drawn from labels that had to move apart                                                                                                                                                     |
+| Field                                         | Meaning                                                                                                                                                                                                                                                      |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `show`                                        | Draws the labels. Off by default, except on a heatmap                                                                                                                                                                                                        |
+| `anchor`                                      | `'outside'`, `'start'`, `'middle'`, `'end'` - where a label sits on its mark. On a bar, `'outside'` is beyond its tip (on either side of zero), `'start'` / `'end'` its left / right end (top / bottom on a vertical bar), inside, and `'middle'` its centre |
+| `select`                                      | Which row of each group is labelled: `'first'`, `'last'`, `'min'`, `'max'`, or a list of them. A group is a series on a line or area plot (default `'last'`), a category on the plots that join dots (default: every dot)                                    |
+| `series`                                      | Labels only these series, by name                                                                                                                                                                                                                            |
+| `color`                                       | `'series'` writes each label in its series' color; any other CSS color writes them all in it (`fontStyle.fill` wins)                                                                                                                                         |
+| `decimals`, `prefix`, `suffix`, `signDisplay` | How the value reads, over `numbers.decimals` ([Number format](theming.md#number-format)); `format` replaces them                                                                                                                                             |
+| `format`                                      | `(value, seriesName, row) => string`; `row` is the labelled row, for its other fields                                                                                                                                                                        |
+| `hoverIsolate`                                | Hovering a label dims every other series                                                                                                                                                                                                                     |
+| `fontStyle`                                   | Text style: `fontSize`, `fill`, `dx`, `dy`, `textAnchor`, `lineAnchor`, `rotate`, `class`, ... Overrides the anchor's placement field by field                                                                                                               |
+| `strokeStyle`                                 | Style of the connector lines drawn from labels that had to move apart                                                                                                                                                                                        |
 
 Where the labels go depends on the plot: the end of each series on a line or area plot, one per bar on a bar, pyramid or histogram, one per point on a scatter, one per cell on a heatmap. On lines, overlapping labels spread apart, share one column and are joined to their points by elbow connectors; the right margin grows to fit them when it is `'auto'`. The spread is tuned by `text.declutter` in the [configuration](theming.md).
 
@@ -148,6 +148,7 @@ type Range = { from?: AxisValue; to?: AxisValue }; // inclusive on both ends
 - A segment applies to a data point (or heatmap cell) inside **any** of its `areas`.
 - An `Area` limits by `x`, `y` or both; leaving one out leaves that axis open.
 - A segment without `areas` is a **catch-all**: it matches every point, is evaluated last, and is overridden by any area-specific segment. A catch-all placed first is a baseline that highlighted ranges override.
+- On a line, the piece that joins two runs of a series is drawn as the first area segment that covers both of its ends (its stroke, not its dots): a dashed range that starts at a year dashes the piece leaving it, even where a faded range ending there owns that year's point. One no area covers both ends of is drawn as the catch-all.
 - `'default'` applies to every series; a named key applies to that series only, and wins over `'default'` where both match.
 - `legend` names the segment on the automatic [legend](legend.md).
 - `facet` limits the segment to the [facet panels](facets.md#markers-and-segments-in-some-panels) it names - a `by` value or a list of them. Without it the segment applies to every panel.

package/docs/theming.md

@@ -49,7 +49,7 @@ resetConfiguration(); // back to the shipped defaults
 | `connector`                                                                                                                                                         | What `styles.connector` falls back to on lollipop, dumbbell, Cleveland and forest plots: `sign` (`positive`, `negative`, `zero` colors), `lengthScheme` and `differenceScheme` (color ramps), `arrow` (`width`, `headLength`, `headAngle` of a connector drawn as an arrow), `outsideOpacity` (the part of a connector outside its `from`-`to` stretch), `capLength` (px, of a forest plot's end caps), `labelFontSize` and `labelGap`                 |
 | `hover`                                                                                                                                                             | Look of the hover marker: `rule`, `dot`, `font`, `area`                                                                                                                                                                                                                                                                                                                                                                                                |
 | `delta`                                                                                                                                                             | The `delta` marker's label, per axis the delta is taken on: `text.x` (beside a vertical delta: `dx: 12`, `textAnchor: 'start'`) and `text.y` (above a horizontal one: `dy: -10`, `textAnchor: 'middle'`). `lineAnchor` picks where along the delta the label sits and how it aligns there                                                                                                                                                              |
-| `timeline`                                                                                                                                                          | The rule (`rule`) and the player bar (`player`: controls, speeds, `stepDuration`, button, track, thumb, toggle)                                                                                                                                                                                                                                                                                                                                        |
+| `timeline`                                                                                                                                                          | The rule (`rule`) and the player bar (`player`: controls, speeds, `stepDuration`, button, track, thumb, toggle); `snap` is how close to its last step (a fraction of the span, `1e-4` by default) a tweened timeline counts as being at it                                                                                                                                                                                                             |
 | `facet`                                                                                                                                                             | The position badge and prev/next buttons                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `frameClip`                                                                                                                                                         | Tolerance for clipping marks to the plot frame                                                                                                                                                                                                                                                                                                                                                                                                         |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "Declarative charts, maps and small multiples for Svelte, built on svelteplot.",
   "license": "MIT",
   "author": "Ezequiel Puerta",