svelteplot 0.3.5-pr-121.9 → 0.3.5

package/dist/marks/Vector.svelte.d.ts

@@ -6,32 +6,32 @@ import type { DataRecord, ChannelAccessor } from '../types/index.js';
 import { type Snippet } from 'svelte';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): Partial<{
-        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
+        filter?: import("../types.js").ConstantAccessor<boolean, Datum>;
         facet?: "auto" | "include" | "exclude";
-        fx: ChannelAccessor<Datum>;
-        fy: ChannelAccessor<Datum>;
-        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
-        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
-        fill: ChannelAccessor<Datum>;
-        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
+        fx: import("../types.js").ChannelAccessor<Datum>;
+        fy: import("../types.js").ChannelAccessor<Datum>;
+        dx: import("../types.js").ConstantAccessor<number, Datum>;
+        dy: import("../types.js").ConstantAccessor<number, Datum>;
+        fill: import("../types.js").ChannelAccessor<Datum>;
+        fillOpacity: import("../types.js").ConstantAccessor<number, Datum>;
         sort: {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/data.js").RawValue, Datum>;
-        stroke: ChannelAccessor<Datum>;
-        strokeWidth: import("../types/index.js").ConstantAccessor<number, Datum>;
-        strokeOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
-        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
-        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
-        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, Datum>;
-        opacity: ChannelAccessor<Datum>;
-        strokeDasharray: import("../types/index.js").ConstantAccessor<string, Datum>;
-        strokeDashoffset: import("../types/index.js").ConstantAccessor<number, Datum>;
-        mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
+        } | ((a: import("../types.js").RawValue, b: import("../types.js").RawValue) => number) | import("../types.js").ConstantAccessor<import("../types.js").RawValue, Datum>;
+        stroke: import("../types.js").ChannelAccessor<Datum>;
+        strokeWidth: import("../types.js").ConstantAccessor<number, Datum>;
+        strokeOpacity: import("../types.js").ConstantAccessor<number, Datum>;
+        strokeLinejoin: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
+        strokeLinecap: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
+        strokeMiterlimit: import("../types.js").ConstantAccessor<number, Datum>;
+        opacity: import("../types.js").ChannelAccessor<Datum>;
+        strokeDasharray: import("../types.js").ConstantAccessor<string, Datum>;
+        strokeDashoffset: import("../types.js").ConstantAccessor<number, Datum>;
+        mixBlendMode: import("../types.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
         clipPath: string;
-        imageFilter: import("../types/index.js").ConstantAccessor<string, Datum>;
-        shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
-        paintOrder: import("../types/index.js").ConstantAccessor<string, Datum>;
+        imageFilter: import("../types.js").ConstantAccessor<string, Datum>;
+        shapeRendering: import("../types.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
+        paintOrder: import("../types.js").ConstantAccessor<string, Datum>;
         onclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
         ondblclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
         onmouseup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
@@ -63,7 +63,7 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         oncontextmenu?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
         onwheel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
         class: string | null;
-        cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
+        cursor: import("../types.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
     }> & {
         data: Datum[];
         x: ChannelAccessor<Datum>;

package/dist/marks/helpers/Anchor.svelte

@@ -1,5 +1,5 @@
 <script>
-    import { resolveProp } from '../../helpers/resolve.js';
+    import { resolveProp } from '../../helpers/resolve';
 
     let { datum = {}, options = {}, children } = $props();
 

package/dist/marks/helpers/AreaCanvas.svelte

@@ -12,7 +12,7 @@
     import CanvasLayer from './CanvasLayer.svelte';
     import type { Attachment } from 'svelte/attachments';
     import { devicePixelRatio } from 'svelte/reactivity/window';
-    import { resolveColor } from './canvas.js';
+    import { resolveColor } from './canvas';
 
     let {
         mark,

package/dist/marks/helpers/BaseAxisX.svelte

@@ -160,8 +160,7 @@
                         tick,
                         options,
                         'stroke',
-                        { x: true },
-                        true
+                        { x: true }
                     )}
                     <line
                         style={tickLineStyle}
@@ -186,8 +185,7 @@
                             stroke: null
                         },
                         'fill',
-                        { x: true },
-                        true
+                        { x: true }
                     )}
                     <text
                         bind:this={tickTextElements[t]}

package/dist/marks/helpers/BaseAxisY.svelte

@@ -21,14 +21,12 @@
         tickSize: number;
         tickPadding: number;
         tickFontSize: ConstantAccessor<number>;
-        tickClass: ConstantAccessor<number>;
         marginLeft: number;
         width: number;
         title: string | null;
         options: {
             dx: ConstantAccessor<number>;
             dy: ConstantAccessor<number>;
-            textAnchor: 'start' | 'middle' | 'end';
         };
         plot: PlotState;
         text: boolean | null;
@@ -95,8 +93,6 @@
     // generate id used for registering margins
     const id = randomId();
 
-    $inspect({ options });
-
     const { autoMarginLeft, autoMarginRight, autoMarginTop } =
         getContext<AutoMarginStores>('svelteplot/autoMargins');
 
@@ -164,8 +160,7 @@
                     stroke: null
                 },
                 'fill',
-                { y: true },
-                true
+                { y: true }
             )}
             <g
                 class="tick {tickClass_ || ''}"
@@ -178,8 +173,7 @@
                         tick,
                         options,
                         'stroke',
-                        { y: true },
-                        true
+                        { y: true }
                     )}
                     <line
                         style={tickLineStyle}
@@ -205,6 +199,10 @@
         stroke: currentColor;
     }
     text {
+        opacity: 0.8;
         fill: currentColor;
     }
+    text.is-left {
+        text-anchor: end;
+    }
 </style>

package/dist/marks/helpers/BaseAxisY.svelte.d.ts

@@ -9,14 +9,12 @@ type BaseAxisYProps = {
     tickSize: number;
     tickPadding: number;
     tickFontSize: ConstantAccessor<number>;
-    tickClass: ConstantAccessor<number>;
     marginLeft: number;
     width: number;
     title: string | null;
     options: {
         dx: ConstantAccessor<number>;
         dy: ConstantAccessor<number>;
-        textAnchor: 'start' | 'middle' | 'end';
     };
     plot: PlotState;
     text: boolean | null;

package/dist/marks/helpers/CanvasLayer.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import { getContext } from 'svelte';
-    import type { PlotContext } from '../../index.js';
+    import type { PlotContext } from '../..';
     import { devicePixelRatio } from 'svelte/reactivity/window';
     import { MediaQuery } from 'svelte/reactivity';
     import type { Attachment } from 'svelte/attachments';

package/dist/marks/helpers/DotCanvas.svelte

@@ -13,7 +13,7 @@
     import CanvasLayer from './CanvasLayer.svelte';
     import { getContext } from 'svelte';
     import { devicePixelRatio } from 'svelte/reactivity/window';
-    import { resolveColor } from './canvas.js';
+    import { resolveColor } from './canvas';
 
     const { getPlotState } = getContext<PlotContext>('svelteplot');
     const plot = $derived(getPlotState());

package/dist/marks/helpers/LineCanvas.svelte

@@ -12,7 +12,7 @@
     import CanvasLayer from './CanvasLayer.svelte';
     import type { Attachment } from 'svelte/attachments';
     import { devicePixelRatio } from 'svelte/reactivity/window';
-    import { resolveColor } from './canvas.js';
+    import { resolveColor } from './canvas';
 
     let {
         mark,

package/dist/marks/helpers/LinearGradientX.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import { getContext } from 'svelte';
-    import type { PlotContext, RawValue } from '../../index.js';
+    import type { PlotContext, RawValue } from '../..';
 
     let {
         id,

package/dist/marks/helpers/LinearGradientX.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { RawValue } from '../../index.js';
+import type { RawValue } from '../..';
 type $$ComponentProps = {
     id: string;
     stops: {

package/dist/marks/helpers/LinearGradientY.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import { getContext } from 'svelte';
-    import type { PlotContext, RawValue } from '../../index.js';
+    import type { PlotContext, RawValue } from '../..';
 
     let {
         id,

package/dist/marks/helpers/LinearGradientY.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { RawValue } from '../../index.js';
+import type { RawValue } from '../..';
 type $$ComponentProps = {
     id: string;
     stops: {

package/dist/marks/helpers/MultilineText.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
     import { resolveProp, resolveStyles } from '../../helpers/resolve';
     import { getContext, type ComponentProps } from 'svelte';
-    import type { PlotContext, ScaledDataRecord, UsedScales } from '../../index.js';
+    import type { PlotContext, ScaledDataRecord, UsedScales } from '../..';
     import type Text from '../Text.svelte';
     import { CSS_VAR } from '../../constants';
     import { maybeFromPixel, maybeFromRem } from '../../helpers/getBaseStyles';

package/dist/marks/helpers/MultilineText.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type ComponentProps } from 'svelte';
-import type { ScaledDataRecord, UsedScales } from '../../index.js';
+import type { ScaledDataRecord, UsedScales } from '../..';
 import type Text from '../Text.svelte';
 type $$ComponentProps = {
     textLines: string[];

package/dist/marks/helpers/RectPath.svelte

@@ -36,8 +36,8 @@ Helper component for rendering rectangular marks in SVG
         UsedScales,
         PlotContext,
         DataRecord
-    } from '../../index.js';
-    import { addEventHandlers } from './events.js';
+    } from '../..';
+    import { addEventHandlers } from './events';
     import { getContext } from 'svelte';
     import Anchor from './Anchor.svelte';
 

package/dist/marks/helpers/RectPath.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { BaseMarkProps, BaseRectMarkProps, ScaledDataRecord, UsedScales, DataRecord } from '../../index.js';
+import type { BaseMarkProps, BaseRectMarkProps, ScaledDataRecord, UsedScales, DataRecord } from '../..';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): {
         datum: ScaledDataRecord<Datum_1>;

package/dist/marks/helpers/Regression.svelte

@@ -33,7 +33,7 @@
 
 <script lang="ts">
     import { getContext } from 'svelte';
-    import { Line, Area } from '../../index.js';
+    import { Line, Area } from '../..';
 
     import {
         regressionLinear,
@@ -47,7 +47,7 @@
     import { resolveChannel } from '../../helpers/resolve.js';
     import { confidenceInterval } from '../../helpers/math.js';
     import callWithProps from '../../helpers/callWithProps.js';
-    import { isDate } from '../../helpers/typeChecks.js';
+    import { isDate } from '../../helpers/typeChecks';
 
     const regressions = new Map<RegressionType, typeof regressionLinear>([
         ['linear', regressionLinear],

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

@@ -1,4 +1,4 @@
-import type { BaseMarkProps, DataRecord, PlotState } from '../../types/index.js';
+import type { BaseMarkProps, DataRecord, PlotState } from '../../types.js';
 declare global {
     interface MouseEvent {
         layerX?: number;

package/dist/transforms/bin.d.ts

@@ -1,5 +1,5 @@
-import type { DataRecord, RawValue } from '../types/index.js';
-import type { TransformArg } from '../types/index.js';
+import type { DataRecord, RawValue } from '../types.js';
+import type { TransformArg } from '../types.js';
 import { type ThresholdCountGenerator } from 'd3-array';
 import { type ReducerName } from '../helpers/reduce.js';
 type NamedThresholdsGenerator = 'auto' | 'scott' | 'sturges' | 'freedman-diaconis';

package/dist/transforms/bollinger.d.ts

@@ -1,4 +1,4 @@
-import type { DataRecord, TransformArg } from '../types/index.js';
+import type { DataRecord, TransformArg } from '../types.js';
 export type BollingerOptions = {
     /**
      * the window size (the window transform’s k option), an integer; defaults to 20
@@ -11,4 +11,69 @@ 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): any;
+export declare function bollingerDim(dim: 'x' | 'y', { data, ...channels }: TransformArg<DataRecord>, options?: BollingerOptions): {
+    filter?: import("../types.js").ConstantAccessor<boolean, DataRecord>;
+    facet?: "auto" | "include" | "exclude" | undefined;
+    fx?: import("../types.js").ChannelAccessor<DataRecord>;
+    fy?: import("../types.js").ChannelAccessor<DataRecord>;
+    dx?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    dy?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    fill?: import("../types.js").ChannelAccessor<DataRecord>;
+    fillOpacity?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    sort?: ((a: import("../types.js").RawValue, b: import("../types.js").RawValue) => number) | {
+        channel: string;
+        order?: "ascending" | "descending";
+    } | import("../types.js").ConstantAccessor<import("../types.js").RawValue, DataRecord>;
+    stroke?: import("../types.js").ChannelAccessor<DataRecord>;
+    strokeWidth?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    strokeOpacity?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    strokeLinejoin?: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, DataRecord>;
+    strokeLinecap?: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, DataRecord>;
+    strokeMiterlimit?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    opacity?: import("../types.js").ChannelAccessor<DataRecord>;
+    strokeDasharray?: import("../types.js").ConstantAccessor<string, DataRecord>;
+    strokeDashoffset?: import("../types.js").ConstantAccessor<number, DataRecord>;
+    mixBlendMode?: import("../types.js").ConstantAccessor<import("csstype").Property.MixBlendMode, DataRecord>;
+    clipPath?: string | undefined;
+    imageFilter?: import("../types.js").ConstantAccessor<string, DataRecord>;
+    shapeRendering?: import("../types.js").ConstantAccessor<import("csstype").Property.ShapeRendering, DataRecord>;
+    paintOrder?: import("../types.js").ConstantAccessor<string, DataRecord>;
+    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 | null | undefined;
+    cursor?: import("../types.js").ConstantAccessor<import("csstype").Property.Cursor, DataRecord>;
+    data: {
+        __x: import("../types.js").RawValue;
+        __lo: number;
+        __avg: number;
+        __hi: number;
+    }[];
+};

package/dist/transforms/centroid.d.ts

@@ -1,4 +1,4 @@
-import type { DataRecord, TransformArg } from '../types/index.js';
+import type { DataRecord, TransformArg } from '../types.js';
 declare const CENTROID: unique symbol;
 type WithCentroid<T> = T & {
     [CENTROID]: [number, number];

package/dist/transforms/filter.d.ts

@@ -1,2 +1,2 @@
-import type { DataRecord, TransformArg } from '../types/index.js';
+import type { DataRecord, TransformArg } from '../types.js';
 export declare function filter({ data, ...channels }: TransformArg<DataRecord>): TransformArg<DataRecord>;

package/dist/transforms/group.d.ts

@@ -1,5 +1,5 @@
 import { type ReducerName } from '../helpers/reduce.js';
-import type { DataRecord, DataRow, RawValue, TransformArg } from '../types/index.js';
+import type { DataRecord, DataRow, RawValue, TransformArg } from '../types.js';
 type ReducerFunc = (group: DataRow[]) => RawValue;
 type ReducerOption = ReducerName | ReducerFunc;
 type GroupBaseOptions = {
@@ -38,21 +38,29 @@ 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): any;
+export declare function group({ data, ...channels }: TransformArg<T, DataRecord>, options?: GroupXOptions): {
+    data: DataRecord[];
+};
 /**
  * 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): any;
+export declare function groupX(input: TransformArg<T, DataRecord>, options?: GroupXOptions): {
+    data: DataRecord[];
+};
 /**
  * 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): any;
+export declare function groupY(input: TransformArg<T, DataRecord>, options?: GroupYOptions): {
+    data: DataRecord[];
+};
 /**
  * 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): any;
+export declare function groupZ(input: TransformArg<T, DataRecord>, options?: GroupZOptions): {
+    data: DataRecord[];
+};
 export {};

package/dist/transforms/interval.d.ts

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

package/dist/transforms/jitter.d.ts

@@ -1,4 +1,4 @@
-import type { Channels, DataRecord, TransformArg } from '../types/index.js';
+import type { Channels, DataRecord, TransformArg } from '../types.js';
 type JitterOptions = {
     type: 'uniform' | 'normal';
     /** width for uniform jittering */

package/dist/transforms/map.d.ts

@@ -1,4 +1,4 @@
-import type { TransformArg, MapOptions, MapMethod } from '../types/index.js';
+import type { TransformArg, MapOptions, MapMethod } from '../types.js';
 export declare function map<T>(args: TransformArg<T>, options: MapOptions): any;
 export declare function mapX<T>(args: TransformArg<T>, mapper: MapMethod): any;
 export declare function mapY<T>(args: TransformArg<T>, mapper: MapMethod): any;

package/dist/transforms/normalize.d.ts

@@ -1,4 +1,4 @@
-import type { TransformArg, MapIndexObject } from '../types/index.js';
+import type { TransformArg, MapIndexObject } from '../types.js';
 type NormalizeBasis = 'deviation' | 'first' | 'last' | 'min' | 'max' | 'mean' | 'median' | 'sum' | 'extent' | MapIndexObject;
 export declare function normalizeX<T>(args: TransformArg<T>, basis: NormalizeBasis): any;
 export declare function normalizeY<T>(args: TransformArg<T>, basis: NormalizeBasis): any;

package/dist/transforms/recordize.d.ts

@@ -1,4 +1,4 @@
-import type { TransformArgsRow, TransformArgsRecord } from '../types/index.js';
+import type { TransformArgsRow, TransformArgsRecord } from '../types.js';
 export declare const INDEX: unique symbol;
 export declare const RAW_VALUE: unique symbol;
 export declare function recordizeX({ data, ...channels }: TransformArgsRow, { withIndex }?: {

package/dist/transforms/rename.d.ts

@@ -1,5 +1,5 @@
-import type { DataRecord } from '../types/index.js';
-import type { ScaledChannelName, TransformArg } from '../types/index.js';
+import type { DataRecord } from '../types.js';
+import type { ScaledChannelName, TransformArg } from '../types.js';
 type RenameChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName>>;
 type ReplaceChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName[]>>;
 /**