svelteplot 0.10.3 → 0.11.0

package/dist/marks/helpers/canvas.js

@@ -1,4 +1,4 @@
-import { CSS_URL, CSS_VAR } from '../../constants';
+import { CSS_URL, CSS_VAR } from '../../constants.js';
 export function resolveColor(color, canvas) {
     if (`${color}`.toLowerCase() === 'currentcolor') {
         color = getComputedStyle(canvas?.parentElement?.parentElement).getPropertyValue('color');
@@ -9,20 +9,27 @@ export function resolveColor(color, canvas) {
     if (CSS_URL.test(color)) {
         // might be a gradient we can parse!
         const m = color.match(/^url\((#[^)]+)\)/);
+        if (!m)
+            return color;
         const gradientId = m[1];
         const gradient = canvas.ownerDocument.querySelector(gradientId);
         if (gradient) {
             // parse gradient
             if (gradient.nodeName.toLowerCase() === 'lineargradient') {
-                const x0 = +gradient.getAttribute('x1');
-                const x1 = +gradient.getAttribute('x2');
-                const y0 = +gradient.getAttribute('y1');
-                const y1 = +gradient.getAttribute('y2');
-                const ctxGradient = canvas.getContext('2d').createLinearGradient(x0, y0, x1, y1);
+                const x0 = +(gradient.getAttribute('x1') ?? 0);
+                const x1 = +(gradient.getAttribute('x2') ?? 0);
+                const y0 = +(gradient.getAttribute('y1') ?? 0);
+                const y1 = +(gradient.getAttribute('y2') ?? 0);
+                const ctx = canvas.getContext('2d');
+                // If we cannot obtain a 2D context, fall back to a safe color instead of returning
+                // the original gradient URL (e.g., "url(#gradient1)"), which is not a valid canvas color.
+                if (!ctx)
+                    return 'transparent';
+                const ctxGradient = ctx.createLinearGradient(x0, y0, x1, y1);
                 for (const stop of gradient.querySelectorAll('stop')) {
-                    const offset = +stop.getAttribute('offset');
-                    const color = resolveColor(stop.getAttribute('stop-color'), canvas);
-                    ctxGradient.addColorStop(Math.min(1, Math.max(0, offset)), color);
+                    const offset = +(stop.getAttribute('offset') ?? 0);
+                    const stopColor = resolveColor(stop.getAttribute('stop-color') ?? '', canvas);
+                    ctxGradient.addColorStop(Math.min(1, Math.max(0, offset)), stopColor);
                 }
                 return ctxGradient;
             }

package/dist/marks/helpers/events.d.ts

@@ -2,8 +2,8 @@ import type { BaseMarkProps, DataRecord, DataRow, PlotState } from '../../types/
 import type { Attachment } from 'svelte/attachments';
 declare global {
     interface MouseEvent {
-        layerX?: number;
-        layerY?: number;
+        readonly layerX: number;
+        readonly layerY: number;
         dataX?: number | string | Date;
         dataY?: number | string | Date;
     }

package/dist/marks/helpers/events.js

@@ -72,7 +72,10 @@ export function addEventHandlers({ options, datum, plot }) {
                         const relativeX = origEvent.clientX - facetRect.left + (plotOptions.marginLeft ?? 0);
                         const relativeY = origEvent.clientY - facetRect.top + (plotOptions.marginTop ?? 0);
                         if (scales.projection) {
-                            const [x, y] = scales.projection.invert([relativeX, relativeY]);
+                            const [x, y] = scales.projection.invert([
+                                relativeX,
+                                relativeY
+                            ]);
                             origEvent.dataX = x;
                             origEvent.dataY = y;
                         }
@@ -100,13 +103,17 @@ export function addEventHandlers({ options, datum, plot }) {
 }
 function invertScale(scale, position) {
     if (scale.type === 'band') {
-        const range = scale.fn.range();
-        const domain = scale.fn.domain();
-        const eachBand = scale.fn.step();
-        const extent = range[1] - range[0];
-        const posInRange = (position - range[0]) * Math.sign(extent);
+        const bandScale = scale.fn;
+        const range = bandScale.range();
+        const domain = bandScale.domain();
+        const eachBand = bandScale.step();
+        const start = range[0] ?? 0;
+        const end = range[1] ?? start;
+        const extent = end - start;
+        const posInRange = (position - start) * Math.sign(extent);
         const index = Math.floor(posInRange / eachBand);
         return domain[index];
     }
-    return scale.fn.invert ? scale.fn.invert(position) : undefined;
+    const maybeInvert = scale.fn;
+    return maybeInvert.invert ? maybeInvert.invert(position) : undefined;
 }

package/dist/marks/helpers/waffle.d.ts

@@ -5,8 +5,8 @@
  * Kept the comments from the original implementation for clarity.
  */
 import type { Snippet } from 'svelte';
-import type { StackOptions } from '../../transforms/stack';
-import type { BorderRadius, ConstantAccessor, PlotScales, ScaledDataRecord } from '../../types';
+import type { StackOptions } from '../../transforms/stack.js';
+import type { BorderRadius, ConstantAccessor, PlotScales, ScaledDataRecord } from '../../types/index.js';
 type Point = [number, number];
 export type WaffleOptions<T> = {
     /**
@@ -58,7 +58,7 @@ type WaffleProps = {
         d: string;
     };
 };
-export declare function wafflePolygon(y: 'x' | 'y', options: WaffleOptions, scales: PlotScales): (d: ScaledDataRecord) => WaffleProps;
+export declare function wafflePolygon(y: 'x' | 'y', options: WaffleOptions<any>, scales: PlotScales): (d: ScaledDataRecord) => WaffleProps;
 export declare function wafflePoints(i1: number, i2: number, columns: number): Point[];
 export declare function maybeRound(round: boolean | ((x: number) => number) | undefined): (x: number) => number;
 export {};

package/dist/marks/helpers/waffle.js

@@ -4,18 +4,20 @@
  *
  * Kept the comments from the original implementation for clarity.
  */
-import { getPatternId } from '../../helpers/getBaseStyles';
+import { getPatternId } from '../../helpers/getBaseStyles.js';
 export function wafflePolygon(y, options, scales) {
     const x = y === 'y' ? 'x' : 'y';
     const y1 = `${y}1`;
     const y2 = `${y}2`;
     const xScale = scales[x];
     const yScale = scales[y];
-    const barwidth = xScale.fn.bandwidth();
+    const xBandScale = xScale.fn;
+    const mapY = (value) => yScale.fn(value) ?? 0;
+    const barwidth = xBandScale.bandwidth();
     const { unit = 1, gap = 1 } = options;
     const round = maybeRound(options.round);
     // The length of a unit along y in pixels.
-    const scale = Math.abs(yScale.fn(unit) - yScale.fn(0));
+    const scale = Math.abs(mapY(unit) - mapY(0));
     // The number of cells on each row (or column) of the waffle.
     const multiple = options.multiple ?? Math.max(1, Math.floor(Math.sqrt(barwidth / scale)));
     // The outer size of each square cell, in pixels, including the gap.
@@ -26,7 +28,7 @@ export function wafflePolygon(y, options, scales) {
     const transform = y === 'y' ? ([x, y]) => [x * cx, -y * cy] : ([x, y]) => [y * cy, x * cx];
     // const mx = typeof x0 === 'function' ? (i) => x0(i) - barwidth / 2 : () => x0;
     const [ix, iy] = y === 'y' ? [0, 1] : [1, 0];
-    const y0 = yScale.fn(0);
+    const y0 = mapY(0);
     const mx = -barwidth / 2;
     return (d) => {
         const y1val = d.resolved[y1];

package/dist/regression/polynomial.d.ts

@@ -1,7 +1,7 @@
 /**
  * Adapted from https://github.com/HarryStevens/d3-regression
  */
-import type { PredictFunction, Accessor, DataPoint, Domain } from './types';
+import type { PredictFunction, Accessor, DataPoint, Domain } from './types.js';
 export type PolynomialOutput = [DataPoint, DataPoint] & {
     coefficients: number[];
     predict: PredictFunction;

package/dist/regression/polynomial.js

@@ -7,11 +7,11 @@
 // ...with ideas from vega-statistics by Jeffrey Heer
 // Source: https://github.com/vega/vega/blob/f21cb8792b4e0cbe2b1a3fd44b0f5db370dbaadb/packages/vega-statistics/src/regression/poly.js
 // License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
-import { determination } from './utils/determination';
-import { interpose } from './utils/interpose';
-import { points, visitPoints } from './utils/points';
-import linear from './linear';
-import quad from './quadratic';
+import { determination } from './utils/determination.js';
+import { interpose } from './utils/interpose.js';
+import { points, visitPoints } from './utils/points.js';
+import linear from './linear.js';
+import quad from './quadratic.js';
 export default function polynomial() {
     let x = (d) => d[0], y = (d) => d[1], order = 3, domain;
     const polynomialRegression = function polynomialRegression(data) {

package/dist/regression/utils/determination.d.ts

@@ -1,4 +1,4 @@
-import type { Accessor, PredictFunction } from '../types';
+import type { Accessor, PredictFunction } from '../types.js';
 /**
  * Given a dataset, x- and y-accessors, the mean center of the y-values (uY),
  * and a prediction function, return the coefficient of determination, R^2.

package/dist/regression/utils/determination.js

@@ -1,4 +1,4 @@
-import { visitPoints } from './points';
+import { visitPoints } from './points.js';
 /**
  * Given a dataset, x- and y-accessors, the mean center of the y-values (uY),
  * and a prediction function, return the coefficient of determination, R^2.

package/dist/regression/utils/geometry.d.ts

@@ -1,4 +1,4 @@
-import type { DataPoint } from '../types';
+import type { DataPoint } from '../types.js';
 /**
  * Returns the angle of a line in degrees.
  */

package/dist/regression/utils/interpose.d.ts

@@ -1,4 +1,4 @@
-import type { PredictFunction, DataPoint } from '../types';
+import type { PredictFunction, DataPoint } from '../types.js';
 /**
  * Given a start point (xmin), an end point (xmax),
  * and a prediction function, returns a smooth line.

package/dist/regression/utils/interpose.js

@@ -1,4 +1,4 @@
-import { angle, midpoint } from './geometry';
+import { angle, midpoint } from './geometry.js';
 /**
  * Given a start point (xmin), an end point (xmax),
  * and a prediction function, returns a smooth line.

package/dist/regression/utils/points.d.ts

@@ -1,4 +1,4 @@
-import type { Accessor } from '../types';
+import type { Accessor } from '../types.js';
 /**
  * Adapted from vega-statistics by Jeffrey Heer
  * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE

package/dist/transforms/bin.d.ts

@@ -36,16 +36,16 @@ type BinOptions = BinBaseOptions & AdditionalOutputChannels;
  * @param param0
  * @param options
  */
-export declare function binX<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinXOptions): TransformArg<T, DataRecord>;
+export declare function binX({ data, ...channels }: TransformArg<DataRecord>, options?: BinXOptions): TransformArg<DataRecord>;
 /**
  * Bins on y. Also groups on y and the first channel of z, fill, or stroke, if any.
  *
  * @param param0
  * @param options
  */
-export declare function binY<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinYOptions): TransformArg<T, DataRecord>;
+export declare function binY({ data, ...channels }: TransformArg<DataRecord>, options?: BinYOptions): TransformArg<DataRecord>;
 /**
  * for binning in x and y dimension simultaneously
  */
-export declare function bin<T>({ data, ...channels }: TransformArg<T, DataRecord>, options?: BinOptions): TransformArg<T, DataRecord>;
+export declare function bin({ data, ...channels }: TransformArg<DataRecord>, options?: BinOptions): TransformArg<DataRecord>;
 export {};

package/dist/transforms/bin.js

@@ -4,7 +4,7 @@ import { bin as d3Bin, extent, thresholdFreedmanDiaconis, thresholdScott, thresh
 import { reduceOutputs } from '../helpers/reduce.js';
 import { groupFacetsAndZ } from '../helpers/group.js';
 import { isDate } from '../helpers/typeChecks.js';
-import { ORIGINAL_NAME_KEYS } from '../constants';
+import { ORIGINAL_NAME_KEYS } from '../constants.js';
 const CHANNELS = {
     x: Symbol('x'),
     x1: Symbol('x1'),
@@ -26,7 +26,9 @@ function binBy(byDim, { data, ...channels }, options) {
         bin.domain(domain);
     if (interval) {
         const [lo, hi] = extent(data.map((d) => resolveChannel(byDim, d, channels)));
-        bin.thresholds(maybeInterval(interval).range(lo, hi));
+        const iv = maybeInterval(interval);
+        if (iv)
+            bin.thresholds(iv.range(lo, hi));
     }
     else if (thresholds)
         bin.thresholds(
@@ -58,13 +60,15 @@ function binBy(byDim, { data, ...channels }, options) {
     const newData = [];
     let passedGroups = [];
     const bins = bin(data);
-    (options.cumulative < 0 ? bins.toReversed() : bins).forEach((group) => {
+    ((options.cumulative ?? 0) < 0 ? bins.toReversed() : bins).forEach((group) => {
+        const x0 = group.x0;
+        const x1 = group.x1;
         const itemBinProps = {
-            [CHANNELS[`${byDim}1`]]: group.x0,
-            [CHANNELS[`${byDim}2`]]: group.x1,
-            [CHANNELS[`${byDim}`]]: isDate(group.x0)
-                ? new Date(Math.round((group.x0.getTime() + group.x1.getTime()) * 0.5))
-                : (group.x0 + group.x1) * 0.5
+            [CHANNELS[`${byDim}1`]]: x0,
+            [CHANNELS[`${byDim}2`]]: x1,
+            [CHANNELS[`${byDim}`]]: isDate(x0)
+                ? new Date(Math.round((x0.getTime() + x1.getTime()) * 0.5))
+                : ((x0 ?? 0) + (x1 ?? 0)) * 0.5
         };
         if (options.cumulative)
             passedGroups = [...passedGroups, ...group];
@@ -99,7 +103,7 @@ export function binY({ data, ...channels }, options = { thresholds: 'auto', cumu
  * for binning in x and y dimension simultaneously
  */
 export function bin({ data, ...channels }, options = { thresholds: 'auto', cumulative: false }) {
-    const { domain, thresholds = 'auto', interval, cumulative = false } = options;
+    const { domain, thresholds = 'auto', interval } = options;
     const binX = d3Bin();
     const binY = d3Bin();
     if (domain) {
@@ -114,8 +118,11 @@ export function bin({ data, ...channels }, options = { thresholds: 'auto', cumul
     if (interval) {
         const [xlo, xhi] = extent(data.map((d) => resolveChannel('x', d, channels)));
         const [ylo, yhi] = extent(data.map((d) => resolveChannel('y', d, channels)));
-        binX.thresholds(maybeInterval(interval).range(xlo, xhi));
-        binY.thresholds((yThresholds = maybeInterval(interval).range(ylo, yhi)));
+        const ivl = maybeInterval(interval);
+        if (ivl) {
+            binX.thresholds(ivl.range(xlo, xhi));
+            binY.thresholds((yThresholds = ivl.range(ylo, yhi)));
+        }
     }
     else if (thresholds) {
         // when binning in x and y, we need to ensure we are using consistent thresholds
@@ -150,17 +157,19 @@ export function bin({ data, ...channels }, options = { thresholds: 'auto', cumul
     // consistent intervals
     const newData = [];
     binX(data).forEach((groupX) => {
+        const gx0 = groupX.x0;
+        const gx1 = groupX.x1;
         const newRecordBaseX = {
-            [CHANNELS.x1]: groupX.x0,
-            [CHANNELS.x2]: groupX.x1,
-            [CHANNELS.x]: isDate(groupX.x0)
-                ? new Date(Math.round((groupX.x0.getTime() + groupX.x1.getTime()) * 0.5))
-                : (groupX.x0 + groupX.x1) * 0.5
+            [CHANNELS.x1]: gx0,
+            [CHANNELS.x2]: gx1,
+            [CHANNELS.x]: isDate(gx0)
+                ? new Date(Math.round((gx0.getTime() + gx1.getTime()) * 0.5))
+                : ((gx0 ?? 0) + (gx1 ?? 0)) * 0.5
         };
         const [ylo, yhi] = extent(groupX.map((d) => resolveChannel('y', d, channels)));
-        const tExtentLo = yThresholds.filter((d) => d < ylo).at(-1);
-        const tExtentHi = yThresholds.filter((d) => d > yhi).at(0);
-        binY(groupX).forEach((groupY, i) => {
+        const tExtentLo = yThresholds.filter((d) => d < ylo).at(-1) ?? ylo;
+        const tExtentHi = yThresholds.filter((d) => d > yhi).at(0) ?? yhi;
+        binY(groupX).forEach((groupY) => {
             if (groupY.length === 0)
                 return;
             // The first bin.x0 is always equal to the minimum domain value,
@@ -174,7 +183,7 @@ export function bin({ data, ...channels }, options = { thresholds: 'auto', cumul
                 [CHANNELS.y2]: y2,
                 [CHANNELS.y]: isDate(y1)
                     ? new Date(Math.round((y1.getTime() + y2.getTime()) * 0.5))
-                    : (y1 + y2) * 0.5
+                    : ((y1 ?? 0) + (y2 ?? 0)) * 0.5
             };
             const newGroupChannels = groupFacetsAndZ(groupY, channels, (items, itemGroupProps) => {
                 const newRecord = {

package/dist/transforms/bollinger.d.ts

@@ -9,6 +9,14 @@ export type BollingerOptions = {
      */
     k?: number;
 };
+/**
+ * computes Bollinger bands for the x channel, producing x1 (lower), x (mean),
+ * and x2 (upper) channels
+ */
 export declare function bollingerX<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
+/**
+ * computes Bollinger bands for the y channel, producing y1 (lower), y (mean),
+ * and y2 (upper) channels
+ */
 export declare function bollingerY<T>(args: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;
 export declare function bollingerDim<T>(dim: 'x' | 'y', { data, ...channels }: TransformArg<T>, options?: BollingerOptions): TransformArg<T>;

package/dist/transforms/bollinger.js

@@ -1,7 +1,15 @@
 import { resolveChannel } from '../helpers/resolve.js';
+/**
+ * computes Bollinger bands for the x channel, producing x1 (lower), x (mean),
+ * and x2 (upper) channels
+ */
 export function bollingerX(args, options = {}) {
     return bollingerDim('x', args, options);
 }
+/**
+ * computes Bollinger bands for the y channel, producing y1 (lower), y (mean),
+ * and y2 (upper) channels
+ */
 export function bollingerY(args, options = {}) {
     return bollingerDim('y', args, options);
 }
@@ -38,7 +46,7 @@ function bollinger(values, N, K) {
         const value = values[i];
         ((sum += value), (sumSquared += value ** 2));
     }
-    for (let n = values.length, m = bands.length; i < n; ++i) {
+    for (let n = values.length; i < n; ++i) {
         const value = values[i];
         ((sum += value), (sumSquared += value ** 2));
         const mean = sum / N;

package/dist/transforms/centroid.d.ts

@@ -3,6 +3,10 @@ declare const CENTROID: unique symbol;
 type WithCentroid<T> = T & {
     [CENTROID]: [number, number];
 };
+/**
+ * computes the geographic centroid of each geometry feature, producing
+ * x (longitude) and y (latitude) channels
+ */
 export declare function geoCentroid<Datum extends DataRecord>({ data, ...options }: {
     data: Datum[];
 } & TransformArg<Datum>): TransformArg<WithCentroid<Datum>>;

package/dist/transforms/centroid.js

@@ -1,6 +1,10 @@
 import { resolveProp } from '../helpers/resolve.js';
 import { geoCentroid as d3GeoCentroid } from 'd3-geo';
 const CENTROID = Symbol('centroid');
+/**
+ * computes the geographic centroid of each geometry feature, producing
+ * x (longitude) and y (latitude) channels
+ */
 export function geoCentroid({ data, ...options }) {
     const transformedData = data.map((d) => ({
         ...d,

package/dist/transforms/density.d.ts

@@ -1,9 +1,10 @@
 /**
  * implementation based on science.js by Jason Davies
  */
-import type { TransformArg } from '../types';
-type Kernel = 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine' | ((u: number) => number);
-type DensityOptions<T> = {
+import type { TransformArg } from '../types/index.js';
+export type KernelName = 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine';
+export type Kernel = KernelName | ((u: number) => number);
+export type DensityOptions<_T> = {
     /**
      * The kernel function to use for smoothing.
      */
@@ -37,4 +38,3 @@ export declare function densityX<T>(args: TransformArg<T>, options: DensityOptio
 export declare function densityY<T>(args: TransformArg<T>, options: DensityOptions<T> & {
     channel?: 'x' | 'x1' | 'x2';
 }): TransformArg<T>;
-export {};

package/dist/transforms/density.js

@@ -9,11 +9,11 @@
  *
  */
 import { extent, quantileSorted, variance } from 'd3-array';
-import { isValid } from '../helpers';
-import { maybeInterval } from '../helpers/autoTicks';
-import { groupFacetsAndZ } from '../helpers/group';
-import isDataRecord from '../helpers/isDataRecord';
-import { resolveChannel } from '../helpers/resolve';
+import { isValid } from '../helpers/index.js';
+import { maybeInterval } from '../helpers/autoTicks.js';
+import { groupFacetsAndZ } from '../helpers/group.js';
+import isDataRecord from '../helpers/isDataRecord.js';
+import { resolveChannel } from '../helpers/resolve.js';
 import { ORIGINAL_NAME_KEYS } from '../constants.js';
 // see https://github.com/jasondavies/science.js/blob/master/src/stats/kernel.js
 const KERNEL = {
@@ -80,6 +80,9 @@ const BANDWIDTH_FACTOR = {
     triweight: 3.15,
     cosine: 1.06
 };
+function isKernelName(value) {
+    return value in KERNEL;
+}
 function bandwidthSilverman(x) {
     const iqr = quantileSorted(x, 0.75) - quantileSorted(x, 0.25);
     const xvar = variance(x);
@@ -128,17 +131,21 @@ function density1d(independent, { data, weight, ...channels }, options = {}) {
         }))).filter((d) => isValid(d[VALUE]) && isValid(d[WEIGHT]) && d[WEIGHT] >= 0);
     const values = resolvedData.map((d) => d[VALUE]);
     // compute bandwidth from full data
+    const kernelName = typeof kernel === 'string' && isKernelName(kernel) ? kernel : null;
     const bw = typeof bandwidth === 'function'
-        ? (BANDWIDTH_FACTOR[kernel] ?? 1) * bandwidth(values.toSorted((a, b) => a - b))
+        ? ((kernelName ? BANDWIDTH_FACTOR[kernelName] : null) ?? 1) *
+            bandwidth(values.toSorted((a, b) => a - b))
         : bandwidth;
     const I = maybeInterval(interval ?? roundToTerminating(bw / 5));
     let [min, max] = extent(values);
     if (!trim) {
-        const r = max - min;
-        min = I.floor(min - r * 0.2);
-        max = I.floor(max + r * 0.2);
+        const r = (max ?? 0) - (min ?? 0);
+        min = I.floor((min ?? 0) - r * 0.2);
+        max = I.floor((max ?? 0) + r * 0.2);
     }
-    const atValues = I.range(I.floor(min), I.offset(max)).map((d) => +d.toFixed(5));
+    const atValues = I
+        .range(I.floor(min), I.offset(max))
+        .map((d) => +d.toFixed(5));
     // let minX = Infinity;
     // let maxX = -Infinity;
     const res = groupFacetsAndZ(resolvedData, channels, (items, groupProps) => {
@@ -149,9 +156,9 @@ function density1d(independent, { data, weight, ...channels }, options = {}) {
             .sort((a, b) => a[0] - b[0]);
         if (!trim) {
             // trim zero values at begin and end except first and last
-            const firstNonZero = kdeValues.findIndex(([x, v]) => v > 0);
+            const firstNonZero = kdeValues.findIndex(([_x, v]) => v > 0);
             // if (firstNonZero > 0) minX = Math.min(minX, kdeValues[firstNonZero - 1][0]);
-            const lastNonZero = kdeValues.length - 1 - [...kdeValues].reverse().findIndex(([x, v]) => v > 0);
+            const lastNonZero = kdeValues.length - 1 - [...kdeValues].reverse().findIndex(([_x, v]) => v > 0);
             // if (lastNonZero > -1 && lastNonZero < kdeValues.length - 1)
             //     maxX = Math.max(maxX, kdeValues[lastNonZero + 1][0]);
             kdeValues = kdeValues.slice(firstNonZero < 1 ? 0 : firstNonZero - 1, lastNonZero < 0 ? kdeValues.length : lastNonZero + 1);
@@ -219,7 +226,7 @@ function kde1d(values, weights, atValues, kernel, bw, cumulative) {
 function maybeKernel(kernel) {
     if (typeof kernel === 'function')
         return kernel;
-    return KERNEL[kernel] || KERNEL.epanechnikov;
+    return isKernelName(kernel) ? KERNEL[kernel] : KERNEL.epanechnikov;
 }
 // See <http://en.wikipedia.org/wiki/Kernel_(statistics)>.
 // science.stats.kernel = {

package/dist/transforms/dodge.d.ts

@@ -1,17 +1,28 @@
-import type { ScaledDataRecord, TransformArg, PlotState } from '../types';
+import type { ScaledDataRecord, TransformArg, PlotState } from '../types/index.js';
 type BaseDodgeOptions = {
+    /** the anchor side for placing dodged marks */
     anchor?: string;
+    /** the padding between dodged marks, in pixels */
     padding?: number;
+    /** the radius of dodged marks, in pixels */
     r?: number;
 };
 type AnchorX = 'left' | 'right' | 'middle';
 type AnchorY = 'top' | 'bottom' | 'middle';
+/** options for horizontal dodge positioning; can be an anchor string or a full options object */
 export type DodgeXOptions = AnchorX | (BaseDodgeOptions & {
     anchor?: 'left' | 'right' | 'middle';
 });
+/** options for vertical dodge positioning; can be an anchor string or a full options object */
 export type DodgeYOptions = AnchorY | (BaseDodgeOptions & {
     anchor?: 'top' | 'bottom' | 'middle';
 });
+/**
+ * offsets marks horizontally to avoid overlap, using circle-packing
+ */
 export declare function dodgeX(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+/**
+ * offsets marks vertically to avoid overlap, using circle-packing
+ */
 export declare function dodgeY(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
 export {};

package/dist/transforms/dodge.js

@@ -1,9 +1,12 @@
 import IntervalTree from 'interval-tree-1d';
-import { groupFacetsAndZ } from '../helpers/group';
+import { groupFacetsAndZ } from '../helpers/group.js';
+/**
+ * offsets marks horizontally to avoid overlap, using circle-packing
+ */
 export function dodgeX(args, plotState) {
     if (!args.dodgeX)
         return args.data;
-    let { anchor = 'left', padding = 1, r = args.dodgeX.r } = maybeAnchor(args.dodgeX);
+    let { anchor = 'left', padding = 1, r = args.dodgeX?.r } = maybeAnchor(args.dodgeX);
     let anchorFunction;
     switch (`${anchor}`.toLowerCase()) {
         case 'left':
@@ -20,10 +23,13 @@ export function dodgeX(args, plotState) {
     }
     return dodge('x', 'y', anchorFunction, Number(padding), r, args, plotState);
 }
+/**
+ * offsets marks vertically to avoid overlap, using circle-packing
+ */
 export function dodgeY(args, plotState) {
     if (!args.dodgeY)
         return args.data;
-    let { anchor = 'bottom', padding = 1, r = args.dodgeY.r } = maybeAnchor(args.dodgeY);
+    let { anchor = 'bottom', padding = 1, r = args.dodgeY?.r } = maybeAnchor(args.dodgeY);
     let anchorFunction;
     switch (`${anchor}`.toLowerCase()) {
         case 'top':
@@ -57,7 +63,9 @@ function dodge(y, x, anchor, padding, r, { data, ...channels }, plotState) {
     groupFacetsAndZ(data, { fx, fy }, (items) => {
         // apply dodge within each facet
         const tree = IntervalTree();
-        const data = items.filter((d) => (typeof d.r !== 'number' || d.r >= 0) && isFinite(d[x]) && isFinite(d[y]));
+        const data = items.filter((d) => (typeof d.r !== 'number' || d.r >= 0) &&
+            isFinite(d[x]) &&
+            isFinite(d[y]));
         const intervals = new Float64Array(2 * data.length + 2);
         data.forEach((d, i) => {
             const ri = d.r ?? r ?? 3;
@@ -69,7 +77,8 @@ function dodge(y, x, anchor, padding, r, { data, ...channels }, plotState) {
             // For any previously placed circles that may overlap this circle, compute
             // the y-positions that place this circle tangent to these other circles.
             // https://observablehq.com/@mbostock/circle-offset-along-line
-            tree.queryInterval(l - padding, h + padding, ([, , j]) => {
+            tree.queryInterval(l - padding, h + padding, (interval) => {
+                const j = interval[2];
                 const yj = data[j][y] - y0;
                 const dx = d[x] - data[j][x];
                 const dr = padding + (channels.r ? d.r + data[j].r : 2 * cr);
@@ -117,7 +126,7 @@ function anchorYTop({ options: { marginTop } }) {
 function anchorYBottom({ facetHeight: height }) {
     return [-1, height];
 }
-function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom } }) {
+function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom: _marginBottom } }) {
     return [0, (marginTop + height) / 2];
 }
 function compareSymmetric(a, b) {