svelteplot 0.8.1 → 0.9.0-pr-309.0

package/dist/marks/helpers/trail.js

@@ -0,0 +1,372 @@
+import { TAU } from '../../constants.js';
+import { maybeCurve } from '../../helpers/curves.js';
+/**
+ * Draw a stroked capsule trail along successive points with varying widths.
+ * Adapted from Vega's trail mark implementation.
+ */
+export function trailPath(samples, defined, context, options = {}) {
+    const { curve = 'linear', cap = 'round', tension = 0.5 } = options;
+    const samplesPerSegment = options.samplesPerSegment ?? estimateSamplesPerSegment(samples, defined);
+    const curveFactory = maybeCurve(curve, tension);
+    let drawSamples = samples;
+    let drawDefined = defined;
+    if (curve !== 'linear' || tension !== 0) {
+        const smoothedSamples = [];
+        const smoothedDefined = [];
+        const len = Math.min(samples.length, defined.length);
+        let i = 0;
+        while (i < len) {
+            if (!defined[i]) {
+                smoothedSamples.push(samples[i]);
+                smoothedDefined.push(false);
+                i += 1;
+                continue;
+            }
+            const segment = [];
+            while (i < len && defined[i]) {
+                segment.push(samples[i]);
+                i += 1;
+            }
+            const resampled = resampleCurve(segment, curveFactory, Math.max(1, samplesPerSegment));
+            smoothedSamples.push(...resampled);
+            smoothedDefined.push(...new Array(resampled.length).fill(true));
+            // preserve a gap between defined segments
+            if (i < len) {
+                smoothedSamples.push(samples[i]);
+                smoothedDefined.push(false);
+            }
+        }
+        drawSamples = smoothedSamples;
+        drawDefined = smoothedDefined;
+    }
+    const len = Math.min(drawSamples.length, drawDefined.length);
+    if (len === 0)
+        return;
+    // Butt caps: build joined polygon offsets using angle bisectors to avoid gaps.
+    if (cap === 'butt') {
+        const normalizeVec = (x, y) => {
+            const lenVec = Math.hypot(x, y);
+            return lenVec === 0 ? [0, 0] : [x / lenVec, y / lenVec];
+        };
+        let i = 0;
+        while (i < len) {
+            if (!drawDefined[i]) {
+                i += 1;
+                continue;
+            }
+            const runStart = i;
+            while (i < len && drawDefined[i])
+                i += 1;
+            const runEnd = i - 1;
+            const left = [];
+            const right = [];
+            for (let j = runStart; j <= runEnd; j += 1) {
+                const curr = drawSamples[j];
+                const r = curr.r;
+                const hasPrev = j > runStart;
+                const hasNext = j < runEnd;
+                const prev = hasPrev ? drawSamples[j - 1] : curr;
+                const next = hasNext ? drawSamples[j + 1] : curr;
+                const dirPrev = hasPrev
+                    ? normalizeVec(curr.x - prev.x, curr.y - prev.y)
+                    : normalizeVec(next.x - curr.x, next.y - curr.y);
+                const dirNext = hasNext ? normalizeVec(next.x - curr.x, next.y - curr.y) : dirPrev;
+                const normPrev = [-dirPrev[1], dirPrev[0]];
+                const normNext = [-dirNext[1], dirNext[0]];
+                let nx = normPrev[0] + normNext[0];
+                let ny = normPrev[1] + normNext[1];
+                const nLen = Math.hypot(nx, ny);
+                if (nLen < 1e-6) {
+                    // Straight/180-deg turn: fall back to current normal.
+                    nx = normPrev[0];
+                    ny = normPrev[1];
+                }
+                else {
+                    nx /= nLen;
+                    ny /= nLen;
+                }
+                // Scale to preserve half-width along the miter direction.
+                const dot = nx * normPrev[0] + ny * normPrev[1];
+                const safeDot = Math.abs(dot) < 1e-6 ? 1 : dot;
+                const scale = r / safeDot;
+                const ox = nx * scale;
+                const oy = ny * scale;
+                left.push([curr.x + ox, curr.y + oy]);
+                right.push([curr.x - ox, curr.y - oy]);
+            }
+            if (left.length > 0) {
+                context.moveTo(left[0][0], left[0][1]);
+                for (let j = 1; j < left.length; j += 1) {
+                    context.lineTo(left[j][0], left[j][1]);
+                }
+                for (let j = right.length - 1; j >= 0; j -= 1) {
+                    context.lineTo(right[j][0], right[j][1]);
+                }
+                context.closePath();
+            }
+        }
+        return typeof context.toString === 'function' ? context.toString() : undefined;
+    }
+    // Round caps: original capsule behavior.
+    let ready = false;
+    let x1 = 0;
+    let y1 = 0;
+    let r1 = 0;
+    function point(x2, y2, r2, isStartOfRun, isEndOfRun) {
+        if (ready) {
+            let ux = y1 - y2;
+            let uy = x2 - x1;
+            if (ux || uy) {
+                // compute normal vector scaled by radius
+                const ud = Math.hypot(ux, uy);
+                const rx = (ux /= ud) * r1;
+                const ry = (uy /= ud) * r1;
+                const t = Math.atan2(uy, ux);
+                // keep rounded joins for interior segments even when using butt caps
+                const drawStartCap = !isStartOfRun || cap === 'round';
+                const drawEndCap = !isEndOfRun || cap === 'round';
+                context.moveTo(x1 - rx, y1 - ry);
+                context.lineTo(x2 - ux * r2, y2 - uy * r2);
+                if (drawEndCap) {
+                    context.arc(x2, y2, r2, t - Math.PI, t);
+                }
+                else {
+                    context.lineTo(x2 + ux * r2, y2 + uy * r2);
+                }
+                context.lineTo(x1 + rx, y1 + ry);
+                if (drawStartCap) {
+                    context.arc(x1, y1, r1, t, t + Math.PI);
+                }
+            }
+            else {
+                if (cap === 'round' || (!isStartOfRun && !isEndOfRun)) {
+                    context.arc(x2, y2, r2, 0, TAU);
+                }
+            }
+            context.closePath();
+        }
+        else {
+            ready = true;
+        }
+        x1 = x2;
+        y1 = y2;
+        r1 = r2;
+    }
+    let i = 0;
+    while (i < len) {
+        // Skip gaps
+        if (!drawDefined[i]) {
+            i += 1;
+            ready = false;
+            continue;
+        }
+        const runStart = i;
+        while (i < len && drawDefined[i])
+            i += 1;
+        const runEnd = i - 1;
+        // Prime the first point of the run
+        const first = drawSamples[runStart];
+        ready = false;
+        x1 = first.x;
+        y1 = first.y;
+        r1 = first.r;
+        ready = true;
+        for (let j = runStart + 1; j <= runEnd; j += 1) {
+            const { x: x2, y: y2, r } = drawSamples[j];
+            const isStart = j - 1 === runStart;
+            const isEnd = j === runEnd;
+            point(Number(x2), Number(y2), Number(r), isStart, isEnd);
+        }
+        ready = false;
+    }
+    return typeof context.toString === 'function' ? context.toString() : undefined;
+}
+function resampleCurve(points, curveFactory, samplesPerSegment) {
+    if (points.length === 0)
+        return [];
+    const commands = [];
+    let pendingRadius = points[0].r;
+    let currentRadius = points[0].r;
+    let currentPoint = null;
+    const ctx = {
+        beginPath() { },
+        closePath() { },
+        moveTo(x, y) {
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+            commands.push({ type: 'move', to: [x, y], r: currentRadius });
+        },
+        lineTo(x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'line',
+                from: [from[0], from[1], currentRadius],
+                to: [x, y, pendingRadius]
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        bezierCurveTo(x1, y1, x2, y2, x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'cubic',
+                from: [from[0], from[1], currentRadius],
+                cp1: [x1, y1],
+                cp2: [x2, y2],
+                to: [x, y, pendingRadius]
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        quadraticCurveTo(x1, y1, x, y) {
+            const from = currentPoint ?? [x, y];
+            commands.push({
+                type: 'quad',
+                from: [from[0], from[1], currentRadius],
+                cp: [x1, y1],
+                to: [x, y, pendingRadius]
+            });
+            currentPoint = [x, y];
+            currentRadius = pendingRadius;
+        },
+        arc() { },
+        rect() { }
+    };
+    const curve = curveFactory(ctx);
+    curve.lineStart();
+    for (let idx = 0; idx < points.length; idx += 1) {
+        const pt = points[idx];
+        pendingRadius = pt.r;
+        curve.point(pt.x, pt.y);
+    }
+    curve.lineEnd();
+    const geom = flattenCommands(commands, samplesPerSegment);
+    if (geom.length === 0)
+        return geom;
+    // Re-map radii along the resampled path using the original cumulative
+    // length as the parameter to avoid curve-specific radius drift.
+    const origCum = [0];
+    for (let i = 1; i < points.length; i += 1) {
+        const dx = points[i].x - points[i - 1].x;
+        const dy = points[i].y - points[i - 1].y;
+        origCum.push(origCum[i - 1] + Math.hypot(dx, dy));
+    }
+    const origTotal = origCum[origCum.length - 1] || 1;
+    const resCum = [0];
+    for (let i = 1; i < geom.length; i += 1) {
+        const dx = geom[i].x - geom[i - 1].x;
+        const dy = geom[i].y - geom[i - 1].y;
+        resCum.push(resCum[i - 1] + Math.hypot(dx, dy));
+    }
+    const resTotal = resCum[resCum.length - 1] || 1;
+    const radiusAt = (target) => {
+        let idx = 1;
+        while (idx < origCum.length && origCum[idx] < target)
+            idx += 1;
+        if (idx === origCum.length)
+            return points[points.length - 1].r;
+        const t0 = origCum[idx - 1];
+        const t1 = origCum[idx];
+        const r0 = points[idx - 1].r;
+        const r1 = points[idx].r;
+        const t = t1 === t0 ? 0 : (target - t0) / (t1 - t0);
+        return lerp(r0, r1, t);
+    };
+    for (let i = 0; i < geom.length; i += 1) {
+        const frac = resCum[i] / resTotal;
+        geom[i].r = Number(radiusAt(frac * origTotal).toFixed(2));
+    }
+    return geom;
+}
+function flattenCommands(commands, samplesPerSegment, precision = 2) {
+    const result = [];
+    let last = null;
+    const round = (v) => {
+        const m = 10 ** precision;
+        return Math.round(v * m) / m;
+    };
+    const pushPoint = (x, y, r) => {
+        x = round(x);
+        y = round(y);
+        r = round(r);
+        if (!last || last[0] !== x || last[1] !== y || last[2] !== r) {
+            result.push({ x, y, r });
+            last = [x, y, r];
+        }
+    };
+    for (const cmd of commands) {
+        if (cmd.type === 'move') {
+            pushPoint(cmd.to[0], cmd.to[1], cmd.r);
+            continue;
+        }
+        if (cmd.type === 'line') {
+            const [x1, y1, r1] = cmd.from;
+            const [x2, y2, r2] = cmd.to;
+            for (let step = 1; step <= samplesPerSegment; step += 1) {
+                const t = step / samplesPerSegment;
+                pushPoint(lerp(x1, x2, t), lerp(y1, y2, t), lerp(r1, r2, t));
+            }
+            continue;
+        }
+        if (cmd.type === 'cubic') {
+            const [x0, y0, r0] = cmd.from;
+            const [x1, y1] = cmd.cp1;
+            const [x2, y2] = cmd.cp2;
+            const [x3, y3, r3] = cmd.to;
+            for (let step = 1; step <= samplesPerSegment; step += 1) {
+                const t = step / samplesPerSegment;
+                pushPoint(cubic(x0, x1, x2, x3, t), cubic(y0, y1, y2, y3, t), lerp(r0, r3, t));
+            }
+            continue;
+        }
+        if (cmd.type === 'quad') {
+            const [x0, y0, r0] = cmd.from;
+            const [cx, cy] = cmd.cp;
+            const [x1, y1, r1] = cmd.to;
+            for (let step = 1; step <= samplesPerSegment; step += 1) {
+                const t = step / samplesPerSegment;
+                pushPoint(quad(x0, cx, x1, t), quad(y0, cy, y1, t), lerp(r0, r1, t));
+            }
+        }
+    }
+    return result;
+}
+function cubic(p0, p1, p2, p3, t) {
+    const it = 1 - t;
+    return it * it * it * p0 + 3 * it * it * t * p1 + 3 * it * t * t * p2 + t * t * t * p3;
+}
+function quad(p0, p1, p2, t) {
+    const it = 1 - t;
+    return it * it * p0 + 2 * it * t * p1 + t * t * p2;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function estimateSamplesPerSegment(samples, defined) {
+    const n = Math.min(samples.length, defined.length);
+    let distSum = 0;
+    let distCount = 0;
+    let rSum = 0;
+    let rCount = 0;
+    for (let i = 0; i < n; i++) {
+        if (defined[i]) {
+            rSum += samples[i].r;
+            rCount += 1;
+        }
+        if (i === 0 || !defined[i] || !defined[i - 1])
+            continue;
+        const dx = samples[i].x - samples[i - 1].x;
+        const dy = samples[i].y - samples[i - 1].y;
+        const d = Math.hypot(dx, dy);
+        if (isFinite(d) && d > 0) {
+            distSum += d;
+            distCount += 1;
+        }
+    }
+    const meanDist = distCount ? distSum / distCount : 0;
+    const meanRadius = rCount ? rSum / rCount : 0;
+    const base = meanRadius > 0 ? meanDist / meanRadius : meanDist;
+    // Keep within a reasonable range to avoid excessive subdivision.
+    return Math.max(1, Math.min(32, Math.round(base || 1)));
+}
+export default trailPath;

package/dist/marks/index.d.ts

@@ -45,6 +45,7 @@ export { default as Spike } from './Spike.svelte';
 export { default as Text } from './Text.svelte';
 export { default as TickX } from './TickX.svelte';
 export { default as TickY } from './TickY.svelte';
+export { default as Trail } from './Trail.svelte';
 export { default as Vector } from './Vector.svelte';
 export { default as WaffleX } from './WaffleX.svelte';
 export { default as WaffleY } from './WaffleY.svelte';

package/dist/marks/index.js

@@ -45,6 +45,7 @@ export { default as Spike } from './Spike.svelte';
 export { default as Text } from './Text.svelte';
 export { default as TickX } from './TickX.svelte';
 export { default as TickY } from './TickY.svelte';
+export { default as Trail } from './Trail.svelte';
 export { default as Vector } from './Vector.svelte';
 export { default as WaffleX } from './WaffleX.svelte';
 export { default as WaffleY } from './WaffleY.svelte';

package/dist/transforms/bollinger.d.ts

@@ -11,72 +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>>;
-    dodgeX?: import("./dodge").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge").DodgeYOptions | undefined;
-    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?: ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | 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/centroid.d.ts

@@ -1,8 +1,5 @@
 import type { DataRecord, TransformArg } from '../types/index.js';
-declare const CENTROID: unique symbol;
-type WithCentroid<T> = T & {
-    [CENTROID]: [number, number];
-};
+type WithCentroid<T> = T & {};
 export declare function geoCentroid<Datum extends DataRecord>({ data, ...options }: {
     data: Datum[];
 } & TransformArg<Datum>): TransformArg<WithCentroid<Datum>>;

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,133 +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>;
-    dodgeX?: import("./dodge").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge").DodgeYOptions | undefined;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    sort?: ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | 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>;
-    dodgeX?: import("./dodge").DodgeXOptions | undefined;
-    dodgeY?: import("./dodge").DodgeYOptions | undefined;
-    fill?: import("../types/index.js").ChannelAccessor<T>;
-    fillOpacity?: import("../types/index.js").ConstantAccessor<number, T>;
-    sort?: ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | {
-        channel: string;
-        order?: "ascending" | "descending";
-    } | 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;