svelteplot 0.4.6 → 0.4.7-pr-219.0

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 {};

package/dist/transforms/interval.d.ts

@@ -1,129 +1,7 @@
 import type { PlotState, TransformArg } from '../types/index.js';
 export declare function intervalX<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<T>;
-    fy?: import("../types/index.js").ChannelAccessor<T>;
-    dx?: import("../types/index.js").ConstantAccessor<number, T>;
-    dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    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, T>;
-    stroke?: import("../types/index.js").ChannelAccessor<T>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
-    opacity?: import("../types/index.js").ChannelAccessor<T>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
-    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, T>;
-    data: T[];
-};
+}): any;
 export declare function intervalY<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): {
-    filter?: import("../types/index.js").ConstantAccessor<boolean, T>;
-    facet?: "auto" | "include" | "exclude" | undefined;
-    fx?: import("../types/index.js").ChannelAccessor<T>;
-    fy?: import("../types/index.js").ChannelAccessor<T>;
-    dx?: import("../types/index.js").ConstantAccessor<number, T>;
-    dy?: import("../types/index.js").ConstantAccessor<number, T>;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    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, T>;
-    stroke?: import("../types/index.js").ChannelAccessor<T>;
-    strokeWidth?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    strokeLinejoin?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, T>;
-    strokeLinecap?: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, T>;
-    strokeMiterlimit?: import("../types/index.js").ConstantAccessor<number, T>;
-    opacity?: import("../types/index.js").ChannelAccessor<T>;
-    strokeDasharray?: import("../types/index.js").ConstantAccessor<string, T>;
-    strokeDashoffset?: import("../types/index.js").ConstantAccessor<number, T>;
-    mixBlendMode?: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, T>;
-    clipPath?: string | undefined;
-    imageFilter?: import("../types/index.js").ConstantAccessor<string, T>;
-    shapeRendering?: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, T>;
-    paintOrder?: import("../types/index.js").ConstantAccessor<string, T>;
-    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, T>;
-    data: T[];
-};
+}): any;

package/dist/transforms/recordize.d.ts

@@ -1,11 +1,8 @@
 import type { TransformArgsRow, TransformArgsRecord } from '../types/index.js';
-import { INDEX } from '../constants';
 export declare const X: unique symbol;
 export declare const Y: unique symbol;
 export declare const RAW_VALUE: unique symbol;
-export declare function indexData<T extends object>(data: T[]): (T & {
-    [INDEX]: number;
-})[];
+export declare function indexData<T extends object>(data: T[]): (T & {})[];
 export declare function recordizeX<T>({ data, ...channels }: TransformArgsRow<T>, { withIndex }?: {
     withIndex: boolean;
 }): TransformArgsRecord<T>;