svelteplot 0.2.8-pr-78.1 → 0.2.9

package/dist/helpers/colors.d.ts

@@ -6,7 +6,7 @@ type SchemeGetter = (n: number) => readonly string[];
 export declare function isOrdinalScheme(scheme: ColorScheme): boolean;
 export declare function ordinalScheme(scheme: string): SchemeGetter | undefined;
 export declare function ordinalRange(scheme: string, length: number): readonly string[] | undefined;
-export declare function maybeBooleanRange(domain: boolean[], scheme?: string): any[] | undefined;
+export declare function maybeBooleanRange(domain: boolean[], scheme?: string): unknown[] | undefined;
 export declare function isQuantitativeScheme(scheme: string): boolean;
 export declare function quantitativeScheme(scheme: string): typeof interpolateBrBG | undefined;
 export declare function isDivergingScheme(scheme: string): boolean;

package/dist/helpers/index.d.ts

@@ -3,8 +3,8 @@ import type { Snippet } from 'svelte';
 /**
  * Returns first argument that is not null or undefined
  */
-export declare function coalesce(...args: (RawValue | undefined | null)[]): any;
-export declare function testFilter(datum: DataRecord, options: Record<ChannelName, ChannelAccessor>): any;
+export declare function coalesce(...args: (RawValue | undefined | null)[]): RawValue | null;
+export declare function testFilter(datum: DataRecord, options: Record<ChannelName, ChannelAccessor>): string | number | boolean | symbol | Date | null;
 export declare function randomId(): string;
 export declare function isSnippet(value: unknown): value is Snippet;
 export declare function isValid(value: RawValue | undefined): value is number | Date | string;

package/dist/helpers/scales.d.ts

@@ -15,7 +15,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
     autoTitle?: undefined;
 } | {
     type: ScaleType;
-    domain: any;
+    domain: RawValue[] | [undefined, undefined];
     range: any;
     fn: any;
     skip: Map<ScaledChannelName, Set<symbol>>;

package/dist/helpers/typeChecks.d.ts

@@ -1,10 +1,10 @@
 import type { RawValue } from '../types.js';
-export declare function isBooleanOrNull(v: RawValue): boolean;
+export declare function isBooleanOrNull(v: RawValue): v is boolean;
 export declare function isDate(v: RawValue): v is Date;
-export declare function isDateOrNull(v: RawValue | null | undefined): boolean;
+export declare function isDateOrNull(v: RawValue | null | undefined): v is Date | null | undefined;
 export declare function isNumberOrNull(v: RawValue | null | undefined): boolean;
 export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): boolean;
-export declare function isStringOrNull(v: RawValue | null | undefined): boolean;
+export declare function isStringOrNull(v: RawValue | null | undefined): v is string | null | undefined;
 export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
-export declare function isColorOrNull(v: RawValue | null | undefined): any;
+export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
 export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/marks/AxisX.svelte

@@ -23,6 +23,8 @@
             | Intl.NumberFormatOptions
             | ((d: RawValue) => string);
         tickClass?: ConstantAccessor<string>;
+        /** ticks is a shorthand for defining data, tickCount or interval */
+        ticks?: number | string | RawValue[];
     } & XOR<
             {
                 /** approximate number of ticks to be generated */
@@ -61,12 +63,13 @@
     };
 
     let {
-        data = [],
+        ticks: magicTicks,
+        data = Array.isArray(magicTicks) ? magicTicks : [],
         automatic = false,
         title,
         anchor = DEFAULTS.axisXAnchor as 'top' | 'bottom',
         facetAnchor = 'auto',
-        interval,
+        interval = typeof magicTicks === 'string' ? magicTicks : undefined,
         tickSize = DEFAULTS.tickSize,
         tickFontSize = DEFAULTS.tickFontSize,
         tickPadding = DEFAULTS.tickPadding,
@@ -74,7 +77,7 @@
         tickFormat,
         tickClass,
         class: className,
-        tickCount,
+        tickCount = typeof magicTicks === 'number' ? magicTicks : undefined,
         tickSpacing,
         ...options
     }: AxisXMarkProps = $props();

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

@@ -12,6 +12,8 @@ export type AxisXMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paint
     tickPadding?: number;
     tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
     tickClass?: ConstantAccessor<string>;
+    /** ticks is a shorthand for defining data, tickCount or interval */
+    ticks?: number | string | RawValue[];
 } & XOR<{
     /** approximate number of ticks to be generated */
     tickCount?: number;

package/dist/marks/AxisY.svelte

@@ -24,6 +24,8 @@
             | Intl.NumberFormatOptions
             | ((d: RawValue) => string);
         tickClass?: ConstantAccessor<string>;
+        /** ticks is a shorthand for defining data, tickCount or interval */
+        ticks?: number | string | RawValue[];
     } & XOR<
             {
                 /** approximate number of ticks to be generated */
@@ -61,19 +63,20 @@
     };
 
     let {
-        data = [],
+        ticks: magicTicks,
+        data = Array.isArray(magicTicks) ? magicTicks : [],
         automatic = false,
         title,
         anchor = DEFAULTS.axisYAnchor as 'left' | 'right',
         facetAnchor = 'auto',
-        interval,
+        interval = typeof magicTicks === 'string' ? magicTicks : undefined,
         lineAnchor = 'center',
         tickSize = DEFAULTS.tickSize,
         tickFontSize = DEFAULTS.tickFontSize,
         tickPadding = DEFAULTS.tickPadding,
         tickFormat,
         tickClass,
-        tickCount,
+        tickCount = typeof magicTicks === 'number' ? magicTicks : undefined,
         tickSpacing,
         ...options
     }: AxisYMarkProps = $props();

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

@@ -13,6 +13,8 @@ export type AxisYMarkProps = Omit<BaseMarkProps, 'fill' | 'fillOpacity' | 'paint
     tickPadding?: number;
     tickFormat?: 'auto' | Intl.DateTimeFormatOptions | Intl.NumberFormatOptions | ((d: RawValue) => string);
     tickClass?: ConstantAccessor<string>;
+    /** ticks is a shorthand for defining data, tickCount or interval */
+    ticks?: number | string | RawValue[];
 } & XOR<{
     /** approximate number of ticks to be generated */
     tickCount?: number;

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

@@ -13,6 +13,6 @@ export type BollingerXMarkProps = BaseMarkProps & {
 };
 import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerX: import("svelte").Component<any, {}, "">;
+declare const BollingerX: import("svelte").Component<BollingerXMarkProps, {}, "">;
 type BollingerX = ReturnType<typeof BollingerX>;
 export default BollingerX;

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

@@ -13,6 +13,6 @@ export type BollingerYMarkProps = BaseMarkProps & {
 };
 import type { BaseMarkProps, ChannelAccessor, DataRow } from '../types.js';
 /** line representing a moving average and an area representing volatility as a band */
-declare const BollingerY: import("svelte").Component<any, {}, "">;
+declare const BollingerY: import("svelte").Component<BollingerYMarkProps, {}, "">;
 type BollingerY = ReturnType<typeof BollingerY>;
 export default BollingerY;

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

@@ -1,6 +1,61 @@
 import { type BaseMarkProps } from '../types.js';
 export type SphereMarkProps = BaseMarkProps;
 /** Geo mark with Sphere geometry object */
-declare const Sphere: import("svelte").Component<BaseMarkProps, {}, "">;
+declare const Sphere: import("svelte").Component<Partial<{
+    filter?: import("../types.js").ConstantAccessor<boolean>;
+    facet?: "auto" | "include" | "exclude";
+    fx: import("../types.js").ChannelAccessor;
+    fy: import("../types.js").ChannelAccessor;
+    dx: import("../types.js").ConstantAccessor<number>;
+    dy: import("../types.js").ConstantAccessor<number>;
+    fill: import("../types.js").ConstantAccessor<string>;
+    fillOpacity: import("../types.js").ConstantAccessor<number>;
+    stroke: import("../types.js").ConstantAccessor<string>;
+    strokeWidth: import("../types.js").ConstantAccessor<number>;
+    strokeOpacity: import("../types.js").ConstantAccessor<number>;
+    strokeLinejoin: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin>;
+    strokeLinecap: import("../types.js").ConstantAccessor<import("csstype").Property.StrokeLinecap>;
+    strokeMiterlimit: import("../types.js").ConstantAccessor<number>;
+    opacity: import("../types.js").ConstantAccessor<number>;
+    strokeDasharray: import("../types.js").ConstantAccessor<string>;
+    strokeDashoffset: import("../types.js").ConstantAccessor<number>;
+    mixBlendMode: import("../types.js").ConstantAccessor<import("csstype").Property.MixBlendMode>;
+    clipPath: string;
+    imageFilter: import("../types.js").ConstantAccessor<string>;
+    shapeRendering: import("../types.js").ConstantAccessor<import("csstype").Property.ShapeRendering>;
+    paintOrder: import("../types.js").ConstantAccessor<string>;
+    onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
+    class: string | null;
+    cursor: import("../types.js").ConstantAccessor<import("csstype").Property.Cursor>;
+}>, {}, "">;
 type Sphere = ReturnType<typeof Sphere>;
 export default Sphere;

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

@@ -1,4 +1,44 @@
+import { type MarkerShape } from './Marker.svelte';
+import type { BaseMarkProps, ConstantAccessor, DataRecord, Mark, PlotScales } from '../../types.js';
+type MarkerPathProps = BaseMarkProps & {
+    /**
+     * the datum associated with this path, usually the first
+     * element of the data array group
+     */
+    datum: DataRecord;
+    /**
+     * the marker shape to use at the start of the path, defaults to
+     * circle
+     */
+    markerStart?: boolean | MarkerShape;
+    /**
+     * the marker shape to use at the middle of the path, defaults to circle
+     */
+    markerMid?: boolean | MarkerShape;
+    /**
+     * the marker shape to use at the end of the path, defaults to circle
+     */
+    markerEnd?: boolean | MarkerShape;
+    /**
+     * shorthand for setting all markers
+     */
+    marker?: boolean | MarkerShape;
+    /**
+     * path string
+     */
+    d: string;
+    style: string;
+    startOffset: string;
+    textStyle: string;
+    textStyleClass?: string | null;
+    text: string;
+    transform: string;
+    color: string;
+    strokeWidth: ConstantAccessor<number>;
+    mark: Mark<BaseMarkProps>;
+    scales: PlotScales;
+};
 /** Helper component for paths with markers and optional text along the path. */
-declare const MarkerPath: import("svelte").Component<any, {}, "">;
+declare const MarkerPath: import("svelte").Component<MarkerPathProps, {}, "">;
 type MarkerPath = ReturnType<typeof MarkerPath>;
 export default MarkerPath;

package/dist/transforms/bollinger.d.ts

@@ -11,4 +11,11 @@ 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): {
+    data: {
+        __x: import("../types.js").RawValue;
+        __lo: number;
+        __avg: number;
+        __hi: number;
+    }[];
+};

package/dist/transforms/centroid.d.ts

@@ -1,2 +1,9 @@
 import type { DataRecord, TransformArg } from '../types.js';
-export declare function geoCentroid({ data, ...options }: TransformArg<DataRecord>): any;
+export declare function geoCentroid({ data, ...options }: TransformArg<DataRecord>): {
+    x: (d: any) => any;
+    y: (d: any) => any;
+    data: {
+        __centroid__: [number, number];
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};

package/dist/transforms/group.d.ts

@@ -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,11 @@
 import type { PlotState, TransformArg } from '../types.js';
 export declare function intervalX<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): any;
+}): {
+    data: T[];
+};
 export declare function intervalY<T>(args: TransformArg<T>, { plot }: {
     plot: PlotState;
-}): any;
+}): {
+    data: T[];
+};

package/dist/transforms/map.d.ts

@@ -1,4 +1,10 @@
-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;
+import type { TransformArg, MapOptions, MapMethod, DataRecord } from '../types.js';
+export declare function map<T>(args: TransformArg<T>, options: MapOptions): {
+    data: DataRecord[];
+};
+export declare function mapX<T>(args: TransformArg<T>, mapper: MapMethod): {
+    data: DataRecord[];
+};
+export declare function mapY<T>(args: TransformArg<T>, mapper: MapMethod): {
+    data: DataRecord[];
+};

package/dist/transforms/normalize.d.ts

@@ -1,5 +1,9 @@
 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;
+export declare function normalizeX<T>(args: TransformArg<T>, basis: NormalizeBasis): {
+    data: import("../types.js").DataRecord[];
+};
+export declare function normalizeY<T>(args: TransformArg<T>, basis: NormalizeBasis): {
+    data: import("../types.js").DataRecord[];
+};
 export {};

package/dist/transforms/select.d.ts

@@ -5,17 +5,31 @@ type AtLeastOne<T, U = {
 type SelectOptions = 'first' | 'last' | AtLeastOne<{
     [k in ChannelName]: 'min' | 'max';
 }>;
-export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): any;
+export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): {
+    data: DataRecord[];
+};
 /**
  * Keeps only the first item of each group
  */
-export declare function selectFirst(args: TransformArg<DataRecord>): any;
+export declare function selectFirst(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
 /**
  * Keeps only the last item of each group
  */
-export declare function selectLast(args: TransformArg<DataRecord>): any;
-export declare function selectMinX(args: TransformArg<DataRecord>): any;
-export declare function selectMaxX(args: TransformArg<DataRecord>): any;
-export declare function selectMinY(args: TransformArg<DataRecord>): any;
-export declare function selectMaxY(args: TransformArg<DataRecord>): any;
+export declare function selectLast(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
 export {};

package/dist/transforms/sort.d.ts

@@ -2,14 +2,27 @@ import type { DataRecord, DataRow, TransformArg } from '../types.js';
 export declare const SORT_KEY: unique symbol;
 export declare function sort({ data, ...channels }: TransformArg<DataRecord>, options?: {
     reverse?: boolean;
-}): any;
+}): {
+    sort: null;
+    data: {
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+} | {
+    data: DataRecord[];
+};
 /**
  * reverses the data row order
  */
 export declare function shuffle({ data, ...channels }: TransformArg<DataRow[]>, options?: {
     seed?: number;
-}): any;
+}): {
+    sort: null;
+    data: DataRow[][];
+};
 /**
  * reverses the data row order
  */
-export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): any;
+export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): {
+    sort: null;
+    data: DataRow[][];
+};

package/dist/transforms/window.d.ts

@@ -7,6 +7,18 @@ type WindowOptions = {
     reduce: ReducerName;
     strict: boolean;
 };
-export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): any;
-export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): any;
+export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): {
+    data: {
+        [x: string]: import("../types.js").RawValue;
+        [x: symbol]: import("../types.js").RawValue;
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};
+export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): {
+    data: {
+        [x: string]: import("../types.js").RawValue;
+        [x: symbol]: import("../types.js").RawValue;
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};
 export {};

package/package.json

@@ -1,127 +1,126 @@
 {
-    "name": "svelteplot",
-    "version": "0.2.8-pr-78.1",
-    "license": "ISC",
-    "author": {
-        "name": "Gregor Aisch",
-        "email": "gka@users.noreply.github.com"
+  "name": "svelteplot",
+  "version": "0.2.9",
+  "license": "ISC",
+  "author": {
+    "name": "Gregor Aisch",
+    "email": "gka@users.noreply.github.com"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
     },
-    "scripts": {
-        "dev": "vite dev",
-        "build": "vite build",
-        "preview": "vite preview",
-        "test": "npm run test:unit",
-        "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-        "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-        "lint": "prettier --check src && eslint src",
-        "format": "prettier --write .",
-        "test:unit": "vitest",
-        "prepack": "npx svelte-package",
-        "release-next": "npm version prerelease --preid next && npm publish && git push && git push --tags && sleep 1 && npm dist-tag add svelteplot@$(npm view . version) next",
-        "docs": "npm run build && cd build && rsync --recursive . vis4.net:svelteplot/alpha0/",
-        "screenshots": "node screenshot-examples.js"
+    "./*.js": {
+      "import": "./dist/*.js"
     },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "svelte": "./dist/index.js"
-        },
-        "./*.js": {
-            "import": "./dist/*.js"
-        },
-        "./*.svelte": {
-            "import": "./dist/*.svelte"
-        },
-        "./core/*.svelte": {
-            "import": "./dist/core/*.svelte"
-        },
-        "./marks/*.svelte": {
-            "import": "./dist/marks/*.svelte"
-        },
-        "./transforms": {
-            "import": "./dist/transforms/index.js"
-        }
+    "./*.svelte": {
+      "import": "./dist/*.svelte"
     },
-    "main": "./dist/index.js",
-    "files": [
-        "dist",
-        "!dist/**/*.test.*",
-        "!dist/**/*.spec.*"
-    ],
-    "devDependencies": {
-        "@aitodotai/json-stringify-pretty-compact": "^1.3.0",
-        "@emotion/css": "^11.13.5",
-        "@sveltejs/adapter-auto": "^6.0.1",
-        "@sveltejs/adapter-static": "^3.0.8",
-        "@sveltejs/eslint-config": "^8.2.0",
-        "@sveltejs/kit": "^2.21.1",
-        "@sveltejs/package": "^2.3.11",
-        "@sveltejs/vite-plugin-svelte": "5.0.3",
-        "@sveltepress/theme-default": "^6.0.3",
-        "@sveltepress/twoslash": "^1.2.2",
-        "@sveltepress/vite": "^1.2.2",
-        "@testing-library/svelte": "^5.2.8",
-        "@testing-library/user-event": "^14.6.1",
-        "@types/d3-array": "^3.2.1",
-        "@types/d3-color": "^3.1.3",
-        "@types/d3-dsv": "^3.0.7",
-        "@types/d3-geo": "^3.1.0",
-        "@types/d3-interpolate": "^3.0.4",
-        "@types/d3-path": "^3.1.1",
-        "@types/d3-random": "^3.0.3",
-        "@types/d3-scale": "^4.0.9",
-        "@types/d3-scale-chromatic": "^3.1.0",
-        "@types/d3-shape": "^3.1.7",
-        "@typescript-eslint/eslint-plugin": "^8.32.1",
-        "@typescript-eslint/parser": "^8.32.1",
-        "csstype": "^3.1.3",
-        "d3-dsv": "^3.0.1",
-        "d3-fetch": "^3.0.1",
-        "d3-force": "^3.0.0",
-        "eslint": "^9.27.0",
-        "eslint-config-prettier": "^10.1.5",
-        "eslint-plugin-svelte": "3.9.0",
-        "jsdom": "^26.1.0",
-        "prettier": "^3.5.3",
-        "prettier-plugin-svelte": "^3.4.0",
-        "puppeteer": "^24.9.0",
-        "remark-code-extra": "^1.0.1",
-        "remark-code-frontmatter": "^1.0.0",
-        "resize-observer-polyfill": "^1.5.1",
-        "sass": "^1.89.0",
-        "svelte-check": "^4.2.1",
-        "svelte-eslint-parser": "1.2.0",
-        "svelte-highlight": "^7.8.3",
-        "svg-path-parser": "^1.1.0",
-        "topojson-client": "^3.1.0",
-        "ts-essentials": "^10.0.4",
-        "tslib": "^2.8.1",
-        "typedoc": "^0.28.5",
-        "typedoc-plugin-markdown": "^4.6.3",
-        "typescript": "^5.8.3",
-        "vite": "^6.3.5",
-        "vitest": "^3.1.4",
-        "vitest-matchmedia-mock": "^2.0.3"
+    "./core/*.svelte": {
+      "import": "./dist/core/*.svelte"
     },
-    "types": "./dist/index.d.ts",
-    "type": "module",
-    "dependencies": {
-        "d3-array": "^3.2.4",
-        "d3-color": "^3.1.0",
-        "d3-format": "^3.1.0",
-        "d3-geo": "^3.1.1",
-        "d3-interpolate": "^3.0.1",
-        "d3-path": "^3.1.0",
-        "d3-quadtree": "^3.0.1",
-        "d3-random": "^3.0.1",
-        "d3-regression": "^1.3.10",
-        "d3-scale": "^4.0.2",
-        "d3-scale-chromatic": "^3.1.0",
-        "d3-shape": "^3.2.0",
-        "d3-time": "^3.1.0",
-        "es-toolkit": "^1.38.0",
-        "fast-equals": "^5.2.2",
-        "merge-deep": "^3.0.3",
-        "svelte": "5.33.2"
+    "./marks/*.svelte": {
+      "import": "./dist/marks/*.svelte"
+    },
+    "./transforms": {
+      "import": "./dist/transforms/index.js"
     }
-}
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "devDependencies": {
+    "@aitodotai/json-stringify-pretty-compact": "^1.3.0",
+    "@emotion/css": "^11.13.5",
+    "@sveltejs/adapter-auto": "^6.0.1",
+    "@sveltejs/adapter-static": "^3.0.8",
+    "@sveltejs/eslint-config": "^8.2.0",
+    "@sveltejs/kit": "^2.21.1",
+    "@sveltejs/package": "^2.3.11",
+    "@sveltejs/vite-plugin-svelte": "5.0.3",
+    "@sveltepress/theme-default": "^6.0.3",
+    "@sveltepress/twoslash": "^1.2.2",
+    "@sveltepress/vite": "^1.2.2",
+    "@testing-library/svelte": "^5.2.8",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/d3-array": "^3.2.1",
+    "@types/d3-color": "^3.1.3",
+    "@types/d3-dsv": "^3.0.7",
+    "@types/d3-geo": "^3.1.0",
+    "@types/d3-interpolate": "^3.0.4",
+    "@types/d3-path": "^3.1.1",
+    "@types/d3-random": "^3.0.3",
+    "@types/d3-scale": "^4.0.9",
+    "@types/d3-scale-chromatic": "^3.1.0",
+    "@types/d3-shape": "^3.1.7",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "csstype": "^3.1.3",
+    "d3-dsv": "^3.0.1",
+    "d3-fetch": "^3.0.1",
+    "d3-force": "^3.0.0",
+    "eslint": "^9.27.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-svelte": "3.9.0",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.4.0",
+    "puppeteer": "^24.9.0",
+    "remark-code-extra": "^1.0.1",
+    "remark-code-frontmatter": "^1.0.0",
+    "resize-observer-polyfill": "^1.5.1",
+    "sass": "^1.89.0",
+    "svelte-check": "^4.2.1",
+    "svelte-eslint-parser": "1.2.0",
+    "svelte-highlight": "^7.8.3",
+    "svg-path-parser": "^1.1.0",
+    "topojson-client": "^3.1.0",
+    "ts-essentials": "^10.0.4",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.5",
+    "typedoc-plugin-markdown": "^4.6.3",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vitest": "^3.1.4",
+    "vitest-matchmedia-mock": "^2.0.3"
+  },
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "dependencies": {
+    "d3-array": "^3.2.4",
+    "d3-color": "^3.1.0",
+    "d3-format": "^3.1.0",
+    "d3-geo": "^3.1.1",
+    "d3-interpolate": "^3.0.1",
+    "d3-path": "^3.1.0",
+    "d3-quadtree": "^3.0.1",
+    "d3-random": "^3.0.1",
+    "d3-regression": "^1.3.10",
+    "d3-scale": "^4.0.2",
+    "d3-scale-chromatic": "^3.1.0",
+    "d3-shape": "^3.2.0",
+    "d3-time": "^3.1.0",
+    "es-toolkit": "^1.38.0",
+    "fast-equals": "^5.2.2",
+    "merge-deep": "^3.0.3",
+    "svelte": "5.33.2"
+  },
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "npm run test:unit",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "prettier --check src && eslint src",
+    "format": "prettier --write .",
+    "test:unit": "vitest",
+    "release-next": "npm version prerelease --preid next && npm publish && git push && git push --tags && sleep 1 && npm dist-tag add svelteplot@$(npm view . version) next",
+    "docs": "npm run build && cd build && rsync --recursive . vis4.net:svelteplot/alpha0/",
+    "screenshots": "node screenshot-examples.js"
+  }
+}