svelteplot 0.4.5-pr-209.2 → 0.4.5-pr-208.4

package/dist/regression/polynomial.js

@@ -0,0 +1,160 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+// Adapted from regression-js by Tom Alexander
+// Source: https://github.com/Tom-Alexander/regression-js/blob/master/src/regression.js#L246
+// License: https://github.com/Tom-Alexander/regression-js/blob/master/LICENSE
+// ...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';
+export default function polynomial() {
+    let x = (d) => d[0], y = (d) => d[1], order = 3, domain;
+    const polynomialRegression = function polynomialRegression(data) {
+        // Shortcut for lower-order polynomials:
+        if (order === 1) {
+            const o = linear().x(x).y(y).domain(domain)(data);
+            const result = [o[0], o[1]];
+            result.coefficients = [o.b, o.a];
+            result.predict = o.predict;
+            result.rSquared = o.rSquared;
+            return result;
+        }
+        if (order === 2) {
+            const o = quad().x(x).y(y).domain(domain)(data);
+            const result = [o[0], o[1]];
+            result.coefficients = [o.c, o.b, o.a];
+            result.predict = o.predict;
+            result.rSquared = o.rSquared;
+            return result;
+        }
+        const [xv, yv, ux, uy] = points(data, x, y);
+        const n = xv.length;
+        const k = order + 1;
+        const lhs = [];
+        const rhs = [];
+        let Y = 0, n0 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx, dy) => {
+            n0++;
+            Y += (dy - Y) / n0;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        // Build normal equations
+        for (let i = 0; i < k; i++) {
+            // LHS
+            let v = 0;
+            for (let l = 0; l < n; l++) {
+                v += Math.pow(xv[l], i) * yv[l];
+            }
+            lhs.push(v);
+            // RHS
+            const c = new Float64Array(k);
+            for (let j = 0; j < k; j++) {
+                let v2 = 0;
+                for (let l = 0; l < n; l++) {
+                    v2 += Math.pow(xv[l], i + j);
+                }
+                c[j] = v2;
+            }
+            rhs.push(c);
+        }
+        rhs.push(new Float64Array(lhs));
+        const coef = gaussianElimination(rhs);
+        const fn = (xx) => {
+            let shifted = xx - ux;
+            let val = uy + coef[0];
+            for (let i = 1; i < k; i++) {
+                val += coef[i] * Math.pow(shifted, i);
+            }
+            return val;
+        };
+        const out = interpose(xmin, xmax, fn);
+        out.coefficients = uncenter(k, coef, -ux, uy);
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    polynomialRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return polynomialRegression;
+    };
+    polynomialRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return polynomialRegression;
+    };
+    polynomialRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return polynomialRegression;
+    };
+    polynomialRegression.order = function (n) {
+        if (!arguments.length)
+            return order;
+        order = n;
+        return polynomialRegression;
+    };
+    return polynomialRegression;
+}
+function uncenter(k, a, x, y) {
+    const z = new Array(k).fill(0);
+    for (let i = k - 1; i >= 0; --i) {
+        let v = a[i];
+        z[i] += v;
+        let c = 1;
+        for (let j = 1; j <= i; ++j) {
+            c *= (i + 1 - j) / j; // binomial coefficient
+            z[i - j] += v * Math.pow(x, j) * c;
+        }
+    }
+    // bias term
+    z[0] += y;
+    return z;
+}
+// Solve A * x = b using Gaussian elimination
+function gaussianElimination(matrix) {
+    const n = matrix.length - 1;
+    const coef = new Array(n);
+    for (let i = 0; i < n; i++) {
+        let r = i;
+        // find pivot row
+        for (let j = i + 1; j < n; j++) {
+            if (Math.abs(matrix[i][j]) > Math.abs(matrix[i][r])) {
+                r = j;
+            }
+        }
+        // swap columns
+        for (let k = i; k < n + 1; k++) {
+            const t = matrix[k][i];
+            matrix[k][i] = matrix[k][r];
+            matrix[k][r] = t;
+        }
+        // reduce
+        for (let j = i + 1; j < n; j++) {
+            for (let k = n; k >= i; k--) {
+                matrix[k][j] -= (matrix[k][i] * matrix[i][j]) / matrix[i][i];
+            }
+        }
+    }
+    for (let j = n - 1; j >= 0; j--) {
+        let t = 0;
+        for (let k = j + 1; k < n; k++) {
+            t += matrix[k][j] * coef[k];
+        }
+        coef[j] = (matrix[n][j] - t) / matrix[j][j];
+    }
+    return coef;
+}

package/dist/regression/power.d.ts

@@ -0,0 +1,18 @@
+import type { PredictFunction, DataPoint, Accessor, Domain } from './types.js';
+export type PowerOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+interface PowerRegression<T> {
+    (data: T[]): PowerOutput;
+    domain(): Domain;
+    domain(domain?: Domain): this;
+    x(): Accessor<T>;
+    x(x: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(y: Accessor<T>): this;
+}
+export default function power<T = DataPoint>(): PowerRegression<T>;
+export {};

package/dist/regression/power.js

@@ -0,0 +1,56 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { interpose } from './utils/interpose.js';
+import { ols } from './utils/ols.js';
+import { visitPoints } from './utils/points.js';
+export default function power() {
+    let x = (d) => d[0], y = (d) => d[1], domain;
+    const powerRegression = function powerRegression(data) {
+        let n = 0, X = 0, Y = 0, XY = 0, X2 = 0, YS = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx, dy) => {
+            const lx = Math.log(dx), ly = Math.log(dy);
+            ++n;
+            X += (lx - X) / n;
+            Y += (ly - Y) / n;
+            XY += (lx * ly - XY) / n;
+            X2 += (lx * lx - X2) / n;
+            YS += (dy - YS) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        let [a, b] = ols(X, Y, XY, X2);
+        a = Math.exp(a);
+        const fn = (xx) => a * Math.pow(xx, b);
+        const out = interpose(xmin, xmax, fn);
+        out.a = a;
+        out.b = b;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, YS, fn);
+        return out;
+    };
+    powerRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return powerRegression;
+    };
+    powerRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return powerRegression;
+    };
+    powerRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return powerRegression;
+    };
+    return powerRegression;
+}

package/dist/regression/quadratic.d.ts

@@ -0,0 +1,19 @@
+import type { Accessor, DataPoint, PredictFunction, Domain } from './types.js';
+export type QuadraticOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    c: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+interface QuadraticRegression<T> {
+    (data: T[]): QuadraticOutput;
+    domain(): Domain;
+    domain(domain?: Domain): this;
+    x(): Accessor<T>;
+    x(x: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(y: Accessor<T>): this;
+}
+export default function quadratic<T = DataPoint>(): QuadraticRegression<T>;
+export {};

package/dist/regression/quadratic.js

@@ -0,0 +1,70 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { interpose } from './utils/interpose.js';
+import { points, visitPoints } from './utils/points.js';
+export default function quadratic() {
+    let x = (d) => d[0], y = (d) => d[1], domain;
+    const quadraticRegression = function quadraticRegression(data) {
+        const [xv, yv, ux, uy] = points(data, (dd) => x(dd), (dd) => y(dd));
+        const n = xv.length;
+        let X2 = 0, X3 = 0, X4 = 0, XY = 0, X2Y = 0, i, dx, dy, x2;
+        for (i = 0; i < n;) {
+            dx = xv[i];
+            dy = yv[i++];
+            x2 = dx * dx;
+            X2 += (x2 - X2) / i;
+            X3 += (x2 * dx - X3) / i;
+            X4 += (x2 * x2 - X4) / i;
+            XY += (dx * dy - XY) / i;
+            X2Y += (x2 * dy - X2Y) / i;
+        }
+        let Y = 0, n0 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx2, dy2) => {
+            n0++;
+            Y += (dy2 - Y) / n0;
+            if (!domain) {
+                if (dx2 < xmin)
+                    xmin = dx2;
+                if (dx2 > xmax)
+                    xmax = dx2;
+            }
+        });
+        const X2X2 = X4 - X2 * X2;
+        const d = X2 * X2X2 - X3 * X3;
+        const a = (X2Y * X2 - XY * X3) / d;
+        const b = (XY * X2X2 - X2Y * X3) / d;
+        const c = -a * X2;
+        const fn = (xx) => {
+            const shifted = xx - ux;
+            return a * shifted * shifted + b * shifted + c + uy;
+        };
+        const out = interpose(xmin, xmax, fn);
+        out.a = a;
+        out.b = b - 2 * a * ux;
+        out.c = c - b * ux + a * ux * ux + uy;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    quadraticRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return quadraticRegression;
+    };
+    quadraticRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return quadraticRegression;
+    };
+    quadraticRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return quadraticRegression;
+    };
+    return quadraticRegression;
+}

package/dist/regression/types.d.ts

@@ -0,0 +1,4 @@
+export type DataPoint = [number, number];
+export type Accessor<T> = (d: T, i?: number, data?: T[]) => number;
+export type PredictFunction = (x: number) => number;
+export type Domain = [number, number] | undefined;

package/dist/regression/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+import type { Accessor, PredictFunction } from '../types';
+/**
+ * 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.
+ */
+export declare function determination<T>(data: T[], x: Accessor<T>, y: Accessor<T>, uY: number, predict: PredictFunction): number;

package/dist/regression/utils/determination.js

@@ -0,0 +1,16 @@
+import { visitPoints } from './points';
+/**
+ * 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.
+ */
+export function determination(data, x, y, uY, predict) {
+    let SSE = 0, // Sum of Squared Errors
+    SST = 0; // Total Sum of Squares
+    visitPoints(data, x, y, (dx, dy) => {
+        const sse = dy - predict(dx);
+        const sst = dy - uY;
+        SSE += sse * sse;
+        SST += sst * sst;
+    });
+    return 1 - SSE / SST;
+}

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

@@ -0,0 +1,9 @@
+import type { DataPoint } from '../types';
+/**
+ * Returns the angle of a line in degrees.
+ */
+export declare function angle(line: [DataPoint, DataPoint]): number;
+/**
+ * Returns the midpoint of a line.
+ */
+export declare function midpoint(line: [DataPoint, DataPoint]): DataPoint;

package/dist/regression/utils/geometry.js

@@ -0,0 +1,12 @@
+/**
+ * Returns the angle of a line in degrees.
+ */
+export function angle(line) {
+    return Math.atan2(line[1][1] - line[0][1], line[1][0] - line[0][0]) * (180 / Math.PI);
+}
+/**
+ * Returns the midpoint of a line.
+ */
+export function midpoint(line) {
+    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];
+}

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

@@ -0,0 +1,6 @@
+import type { PredictFunction, DataPoint } from '../types';
+/**
+ * Given a start point (xmin), an end point (xmax),
+ * and a prediction function, returns a smooth line.
+ */
+export declare function interpose(xmin: number, xmax: number, predict: PredictFunction): [DataPoint, DataPoint];

package/dist/regression/utils/interpose.js

@@ -0,0 +1,37 @@
+import { angle, midpoint } from './geometry';
+/**
+ * Given a start point (xmin), an end point (xmax),
+ * and a prediction function, returns a smooth line.
+ */
+export function interpose(xmin, xmax, predict) {
+    const l = (Math.log(xmax - xmin) * Math.LOG10E + 1) | 0;
+    const precision = Math.pow(10, -l / 2 - 1);
+    const maxIter = 1e4;
+    let points = [px(xmin), px(xmax)];
+    let iter = 0;
+    while (find(points) && iter < maxIter)
+        ;
+    return points;
+    function px(x) {
+        return [x, predict(x)];
+    }
+    function find(points) {
+        iter++;
+        const n = points.length;
+        let found = false;
+        for (let i = 0; i < n - 1; i++) {
+            const p0 = points[i];
+            const p1 = points[i + 1];
+            const m = midpoint([p0, p1]);
+            const mp = px(m[0]);
+            const a0 = angle([p0, m]);
+            const a1 = angle([p0, mp]);
+            const a = Math.abs(a0 - a1);
+            if (a > precision) {
+                points.splice(i + 1, 0, mp);
+                found = true;
+            }
+        }
+        return found;
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Returns the median value of an array of numbers.
+ */
+export declare function median(arr: Float64Array): number;

package/dist/regression/utils/median.js

@@ -0,0 +1,8 @@
+/**
+ * Returns the median value of an array of numbers.
+ */
+export function median(arr) {
+    arr.sort((a, b) => a - b);
+    var i = arr.length / 2;
+    return i % 1 === 0 ? (arr[i - 1] + arr[i]) / 2 : arr[Math.floor(i)];
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Ordinary Least Squares from vega-statistics by Jeffrey Heer
+ * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+ * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/ols.js
+ */
+export declare function ols(uX: number, uY: number, uXY: number, uX2: number): [number, number];

package/dist/regression/utils/ols.js

@@ -0,0 +1,9 @@
+/**
+ * Ordinary Least Squares from vega-statistics by Jeffrey Heer
+ * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+ * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/ols.js
+ */
+export function ols(uX, uY, uXY, uX2) {
+    const delta = uX2 - uX * uX, slope = Math.abs(delta) < 1e-24 ? 0 : (uXY - uX * uY) / delta, intercept = uY - slope * uX;
+    return [intercept, slope];
+}

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

@@ -0,0 +1,11 @@
+import type { Accessor } from '../types';
+/**
+ * Adapted from vega-statistics by Jeffrey Heer
+ * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+ * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/points.js
+ */
+export declare function points<T>(data: T[], x: Accessor<T>, y: Accessor<T>, sort?: boolean): [Float64Array, Float64Array, number, number];
+/**
+ * Iterates over valid data points, invoking a callback for each.
+ */
+export declare function visitPoints<T>(data: T[], x: Accessor<T>, y: Accessor<T>, cb: (dx: number, dy: number, index: number) => void): void;

package/dist/regression/utils/points.js

@@ -0,0 +1,45 @@
+/**
+ * Adapted from vega-statistics by Jeffrey Heer
+ * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+ * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/points.js
+ */
+export function points(data, x, y, sort) {
+    data = data.filter((d, i) => {
+        let u = x(d, i), v = y(d, i);
+        return u != null && isFinite(u) && v != null && isFinite(v);
+    });
+    if (sort) {
+        data.sort((a, b) => x(a) - x(b));
+    }
+    const n = data.length, X = new Float64Array(n), Y = new Float64Array(n);
+    // extract values, calculate means
+    let ux = 0, uy = 0, xv, yv, d;
+    for (let i = 0; i < n;) {
+        d = data[i];
+        X[i] = xv = +x(d, i, data);
+        Y[i] = yv = +y(d, i, data);
+        ++i;
+        ux += (xv - ux) / i;
+        uy += (yv - uy) / i;
+    }
+    // mean center the data
+    for (let i = 0; i < n; ++i) {
+        X[i] -= ux;
+        Y[i] -= uy;
+    }
+    return [X, Y, ux, uy];
+}
+/**
+ * Iterates over valid data points, invoking a callback for each.
+ */
+export function visitPoints(data, x, y, cb) {
+    let iterations = 0;
+    for (let i = 0; i < data.length; i++) {
+        const d = data[i];
+        const dx = +x(d, i, data);
+        const dy = +y(d, i, data);
+        if (dx != null && isFinite(dx) && dy != null && isFinite(dy)) {
+            cb(dx, dy, iterations++);
+        }
+    }
+}

package/dist/transforms/dodge.d.ts

@@ -0,0 +1,17 @@
+import type { ScaledDataRecord, TransformArg, PlotState } from '../types';
+type BaseDodgeOptions = {
+    anchor?: string;
+    padding?: number;
+    r?: number;
+};
+type AnchorX = 'left' | 'right' | 'middle';
+type AnchorY = 'top' | 'bottom' | 'middle';
+export type DodgeXOptions = AnchorX | (BaseDodgeOptions & {
+    anchor?: 'left' | 'right' | 'middle';
+});
+export type DodgeYOptions = AnchorY | (BaseDodgeOptions & {
+    anchor?: 'top' | 'bottom' | 'middle';
+});
+export declare function dodgeX(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+export declare function dodgeY(args: TransformArg<ScaledDataRecord>, plotState: PlotState): ScaledDataRecord[];
+export {};

package/dist/transforms/dodge.js

@@ -0,0 +1,128 @@
+import IntervalTree from 'interval-tree-1d';
+import { groupFacetsAndZ } from '../helpers/group';
+export function dodgeX(args, plotState) {
+    if (!args.dodgeX)
+        return args.data;
+    let { anchor = 'left', padding = 1, r = args.dodgeX.r } = maybeAnchor(args.dodgeX);
+    let anchorFunction;
+    switch (`${anchor}`.toLowerCase()) {
+        case 'left':
+            anchorFunction = anchorXLeft;
+            break;
+        case 'right':
+            anchorFunction = anchorXRight;
+            break;
+        case 'middle':
+            anchorFunction = anchorXMiddle;
+            break;
+        default:
+            throw new Error(`unknown dodge anchor: ${anchor}`);
+    }
+    return dodge('x', 'y', anchorFunction, Number(padding), r, args, plotState);
+}
+export function dodgeY(args, plotState) {
+    if (!args.dodgeY)
+        return args.data;
+    let { anchor = 'bottom', padding = 1, r = args.dodgeY.r } = maybeAnchor(args.dodgeY);
+    let anchorFunction;
+    switch (`${anchor}`.toLowerCase()) {
+        case 'top':
+            anchorFunction = anchorYTop;
+            break;
+        case 'bottom':
+            anchorFunction = anchorYBottom;
+            break;
+        case 'middle':
+            anchorFunction = anchorYMiddle;
+            break;
+        default:
+            throw new Error(`unknown dodge anchor: ${anchor}`);
+    }
+    return dodge('y', 'x', anchorFunction, Number(padding), r, args, plotState);
+}
+function dodge(y, x, anchor, padding, r, { data, ...channels }, plotState) {
+    if (r != null && typeof r !== 'number') {
+        // use the r channel
+        // let { channels, sort, reverse } = options;
+        // channels = maybeNamed(channels);
+        // if (channels?.r === undefined)
+        //     options = { ...options, channels: { ...channels, r: { value: r, scale: 'r' } } };
+        // if (sort === undefined && reverse === undefined) options.sort = { channel: '-r' };
+    }
+    const { fx, fy } = channels;
+    let [ky, ty] = anchor(plotState);
+    const compare = ky ? compareAscending : compareSymmetric;
+    const cr = r !== undefined ? r : 3; // default radius if no r channel
+    // group data by facets
+    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 intervals = new Float64Array(2 * data.length + 2);
+        data.forEach((d, i) => {
+            const ri = d.r ?? r ?? 3;
+            const y0 = ky ? ri + padding : 0; // offset baseline for varying radius
+            const l = d[x] - ri;
+            const h = d[x] + ri;
+            // The first two positions are 0 to test placing the dot on the baseline.
+            let k = 2;
+            // 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]) => {
+                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);
+                const dy = Math.sqrt(dr * dr - dx * dx);
+                intervals[k++] = yj - dy;
+                intervals[k++] = yj + dy;
+            });
+            // Find the best y-value where this circle can fit.
+            let candidates = intervals.slice(0, k);
+            if (ky)
+                candidates = candidates.filter((y) => y >= 0);
+            out: for (const diff of candidates.sort(compare)) {
+                for (let j = 0; j < k; j += 2) {
+                    if (intervals[j] + 1e-6 < diff && diff < intervals[j + 1] - 1e-6) {
+                        continue out;
+                    }
+                }
+                d[y] = diff + y0;
+                break;
+            }
+            // Insert the placed circle into the interval tree.
+            tree.insert([l, h, i]);
+        });
+        if (!ky)
+            ky = 1;
+        data.forEach((d) => (d[y] = d[y] * ky + ty));
+    });
+    return data;
+}
+function maybeAnchor(anchor) {
+    return typeof anchor === 'string' ? { anchor } : anchor;
+}
+function anchorXLeft({ options: { marginLeft } }) {
+    return [1, marginLeft];
+}
+function anchorXRight({ facetWidth: width, options: { marginLeft } }) {
+    return [-1, marginLeft + width];
+}
+function anchorXMiddle({ facetWidth: width, options: { marginLeft } }) {
+    return [0, marginLeft + width / 2];
+}
+function anchorYTop({ options: { marginTop } }) {
+    return [1, marginTop];
+}
+function anchorYBottom({ facetHeight: height }) {
+    return [-1, height];
+}
+function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom } }) {
+    return [0, (marginTop + height) / 2];
+}
+function compareSymmetric(a, b) {
+    return Math.abs(a) - Math.abs(b);
+}
+function compareAscending(a, b) {
+    return a - b;
+}