svelteplot 0.4.6 → 0.4.7-pr-216.0

package/dist/regression/polynomial.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import type { PredictFunction, Accessor, DataPoint, Domain } from './types';
+export type PolynomialOutput = [DataPoint, DataPoint] & {
+    coefficients: number[];
+    predict: PredictFunction;
+    rSquared: number;
+};
+export interface PolynomialRegression<T> {
+    (data: T[]): PolynomialOutput;
+    domain(): Domain;
+    domain(domain?: Domain): this;
+    x(): Accessor<T>;
+    x(x: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(y: Accessor<T>): this;
+    order(): number;
+    order(order: number): this;
+}
+export default function polynomial<T = DataPoint>(): PolynomialRegression<T>;

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/bollinger.d.ts

@@ -11,70 +11,4 @@ export type BollingerOptions = {
 };
 export declare function bollingerX(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
 export declare function bollingerY(args: TransformArg<DataRecord>, options?: BollingerOptions): TransformArg<DataRecord>;
-export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, Record<string | symbol, import("../types/index.js").RawValue>>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    fy?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    dx?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    dy?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    fill?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    sort?: {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, Record<string | symbol, import("../types/index.js").RawValue>>;
-    stroke?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    opacity?: import("../types/index.js").ChannelAccessor<Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, Record<string | symbol, import("../types/index.js").RawValue>>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Record<string | symbol, import("../types/index.js").RawValue>>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Record<string | symbol, import("../types/index.js").RawValue>>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, Record<string | symbol, import("../types/index.js").RawValue>>;
-    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement> | undefined;
-    class?: string | undefined;
-    style?: string | undefined;
-    cursor?: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Record<string | symbol, import("../types/index.js").RawValue>>;
-    data: {
-        __x: import("../types/index.js").RawValue;
-        __lo: number;
-        __avg: number;
-        __hi: number;
-    }[];
-};
+export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): any;

package/dist/transforms/group.d.ts

@@ -38,29 +38,21 @@ type GroupZOptions = GroupXOptions | GroupYOptions;
  * groups the dataset by x and y channel and optionally reduces the group items
  * to output channels fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): {
-    data: Record<string | symbol, RawValue>[];
-};
+export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * groups the dataset by the x channel and optionally reduces the group items
  * to output channels y, y1, y2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): {
-    data: Record<string | symbol, RawValue>[];
-};
+export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): any;
 /**
  * groups the dataset by the y channel and optionally reduces the group items
  * to output channels x, x1, x2, fill, stroke, r, opacity, fillOpacity, or strokeOpacity
  */
-export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): {
-    data: Record<string | symbol, RawValue>[];
-};
+export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): any;
 /**
  * groups the dataset by the z channel and optionally reduces the group items
  * to output channels x, x1, x2, y, y1, y2, fill, stroke, r, opacity, fillOpacity,
  * or strokeOpacity
  */
-export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): {
-    data: Record<string | symbol, RawValue>[];
-};
+export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): any;
 export {};