svelteplot 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/helpers/createScale.d.ts

@@ -0,0 +1,4 @@
+declare const Scales: Record<string, (domain: number[], range: [number, number]) => (val: any) => any>;
+export declare function createScale(type: keyof typeof Scales, domain: any, range: any, options?: {}): (val: any) => any;
+export declare function createColorScale(type: any, domain: string[] | [number, number] | [Date, Date] | [boolean | boolean], scheme: any): ((d: any) => any) | (unknown[] & string[] & import("d3-scale").ScaleOrdinal<string, unknown, never>);
+export {};

package/dist/helpers/createScale.js

@@ -0,0 +1,47 @@
+import { scaleBand, scaleLinear, scaleTime, scaleSqrt, scaleLog, scaleOrdinal } from 'd3-scale';
+import { getLogTicks } from './getLogTicks';
+import { categoricalSchemes, isCategoricalScheme, isOrdinalScheme, ordinalScheme } from './colors';
+import { isColorOrNull } from './typeChecks';
+const Scales = {
+    band: scaleBand,
+    linear: scaleLinear,
+    time: scaleTime,
+    sqrt: scaleSqrt,
+    log: scaleLog,
+    ordinal: scaleOrdinal
+};
+export function createScale(type, domain, range, options = {}) {
+    const scale = Scales[type](domain, range);
+    // allow setting arbiraty scale options
+    for (const [key, val] of Object.entries(options)) {
+        if (typeof scale[key] === 'function')
+            scale[key](val);
+        else
+            console.warn('unknown scale setter ' + key);
+    }
+    if (type === 'log') {
+        // overwrite scaleLog's internal ticks() method
+        scale.ticks = (count) => getLogTicks(domain, count);
+        // console.log({domain})
+        // console.log(getLogTicks(domain, 5))
+    }
+    return scale;
+}
+const identity = (d) => d;
+export function createColorScale(type, domain, scheme) {
+    if (type === 'band') {
+        if (domain.every(isColorOrNull)) {
+            console.log('domain is colors', domain);
+            return identity;
+        }
+        const colorRange = !scheme
+            ? categoricalSchemes.get('tableau10')
+            : Array.isArray(scheme)
+                ? scheme
+                : isCategoricalScheme(scheme)
+                    ? categoricalSchemes.get(scheme)
+                    : ordinalScheme(scheme)(domain.length);
+        return scaleOrdinal().domain(domain).range(colorRange);
+    }
+    return (d) => d;
+}

package/dist/helpers/getBaseStyles.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelAccessor, MarkStyleProps, DataRow } from '../types';
+export default function (datum: DataRow, props: Partial<Record<MarkStyleProps, ChannelAccessor>>): string;

package/dist/helpers/getBaseStyles.js

@@ -0,0 +1,18 @@
+import { MARK_PROP_CHANNEL } from '../contants';
+import resolveChannel from './resolveChannel';
+const styleProps = {
+    fill: 'fill',
+    stroke: 'stroke',
+    strokeWidth: 'stroke-width',
+    strokeDasharray: 'stroke-dasharray',
+    fillOpacity: 'fill-opacity',
+    strokeOpacity: 'stroke-opacity',
+    fontSize: 'font-size',
+    opacity: 'opacity'
+};
+export default function (datum, props) {
+    return Object.entries(styleProps)
+        .filter(([key, cssKey]) => cssKey && props[key] != null)
+        .map(([key, cssKey]) => `${cssKey}: ${resolveChannel(MARK_PROP_CHANNEL[key], datum, props[key])}`)
+        .join(';');
+}

package/dist/helpers/getLogTicks.d.ts

@@ -0,0 +1 @@
+export declare function getLogTicks(domain: [number, number], count?: number): number[];

package/dist/helpers/getLogTicks.js

@@ -0,0 +1,57 @@
+import { ticks as ticksArray } from 'd3-array';
+export function getLogTicks(domain, count = 6) {
+    const inverted = domain[0] < 0 && domain[1] < 0;
+    if (inverted)
+        domain = [domain[0] * -1, domain[1] * -1];
+    const reversed = domain[1] < domain[0];
+    if (reversed)
+        domain = domain.slice(0).reverse();
+    if (domain[0] < 0 || domain[1] < 0)
+        return [];
+    if (domain[0] === 0)
+        return ticksArray(domain[0], domain[1], count - 2);
+    let mult = Math.pow(10, Math.floor(Math.log10(Math.abs(domain[1] - domain[0]))) - 1);
+    count += 2;
+    let candidates = getTickCandidates(domain, mult);
+    if (candidates[0].num > count) {
+        // too many ticks
+        while (candidates[0].num > count) {
+            mult *= 10;
+            candidates = getTickCandidates(domain, mult);
+        }
+    }
+    else if (candidates[candidates.length - 1].num < count) {
+        // not enough ticks, let's fallback to linear ticks
+        const ticksList = ticksArray(domain[0], domain[1], count - 2);
+        if (reversed)
+            ticksList.reverse();
+        return ticksList;
+    }
+    count -= 2;
+    const ticksList = candidates
+        .map((d) => ({
+        ...d,
+        ticks: d.ticks.filter((t) => t >= domain[0] && t <= domain[1])
+    }))
+        .map((d) => ({ ...d, diff: Math.abs(d.ticks.length - count) }))
+        .sort((a, b) => a.diff - b.diff)[0].ticks;
+    if (reversed)
+        ticksList.reverse();
+    if (inverted)
+        return ticksList.map((t) => t * -1);
+    return ticksList;
+}
+const logSeries = [[10], [5, 4, 5], [3, 10 / 3], [2, 2.5, 2], [1.5, 2, 5 / 3, 2]];
+function getTickCandidates(domain, mult = 1) {
+    return logSeries.map((factors) => {
+        let i = Math.pow(10, Math.floor(Math.log10(domain[0])));
+        let f = 0;
+        const r = [i];
+        while (i < domain[1] && r.length < 50) {
+            i *= factors[f] * mult;
+            r.push(i);
+            f = (f + 1) % factors.length;
+        }
+        return { ticks: r, num: r.length };
+    });
+}

package/dist/helpers/isDataRecord.d.ts

@@ -0,0 +1,2 @@
+import type { DataRecord } from '../types';
+export default function (value: any): value is DataRecord;

package/dist/helpers/isDataRecord.js

@@ -0,0 +1,13 @@
+export default function (value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (Object.prototype.toString.call(value) !== '[object Object]')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return true;
+    const Ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+    return (typeof Ctor === 'function' &&
+        Ctor instanceof Ctor &&
+        Function.prototype.call(Ctor) === Function.prototype.call(value));
+}

package/dist/helpers/mergeDeep.d.ts

@@ -0,0 +1,5 @@
+type ObjectType = {
+    [key: string]: any;
+};
+export default function mergeDeep(target: ObjectType, ...sources: ObjectType[]): ObjectType;
+export {};

package/dist/helpers/mergeDeep.js

@@ -0,0 +1,26 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+export default function mergeDeep(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                else {
+                    target[key] = Object.assign({}, target[key]);
+                }
+                mergeDeep(target[key], source[key]);
+            }
+            else if (source[key] !== null) {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}

package/dist/helpers/removeIdenticalLines.d.ts

@@ -0,0 +1 @@
+export default function removeIdenticalLines(input: string[][]): string[][];

package/dist/helpers/removeIdenticalLines.js

@@ -0,0 +1,16 @@
+export default function removeIdenticalLines(input) {
+    const uniqueLines = [];
+    if (!input.length)
+        return input;
+    for (let c = 0; c < input.length; c++) {
+        uniqueLines.push([]);
+    }
+    for (let l = 0; l < input[0].length; l++) {
+        const isIdentical = input.every((value) => input[0][l] === value[l]);
+        for (let c = 0; c < input.length; c++) {
+            if (!isIdentical)
+                uniqueLines[c].push(input[c][l]);
+        }
+    }
+    return uniqueLines;
+}

package/dist/helpers/resolveChannel.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelName, ChannelAccessor, DataRow, RawValue } from '../types';
+export default function (channel: ChannelName, datum: DataRow, accessor?: ChannelAccessor): RawValue;

package/dist/helpers/resolveChannel.js

@@ -0,0 +1,28 @@
+import isDataRecord from './isDataRecord';
+export default function (channel, datum, accessor = null) {
+    if ((channel === 'x' || channel === 'y') && Array.isArray(datum) && accessor === null) {
+        // special case for [[x0,y0], [x1,y1], ...] format
+        return datum[channel === 'x' ? 0 : 1];
+    }
+    else if (isDataRecord(datum)) {
+        // use accessor function
+        if (typeof accessor === 'function')
+            return accessor(datum.___orig___ ? datum.___orig___ : datum);
+        // use accessor string
+        if (typeof accessor === 'string' && datum[accessor] !== undefined)
+            return datum[accessor];
+        // fallback to channel name as accessor
+        if (accessor === null && datum[channel] !== undefined)
+            return datum[channel];
+        // interpret accessor as constant
+        return accessor;
+    }
+    else {
+        // return single value or accessor
+        return typeof accessor === 'function'
+            ? accessor(datum)
+            : accessor !== null
+                ? accessor
+                : datum;
+    }
+}

package/dist/helpers/symbols.d.ts

@@ -0,0 +1,5 @@
+import { type SymbolType } from 'd3-shape';
+export declare const sqrt3: number;
+export declare const sqrt4_3: number;
+export declare function isSymbol(value: string | SymbolType): boolean;
+export declare function maybeSymbol(symbol: SymbolType | string): SymbolType;

package/dist/helpers/symbols.js

@@ -0,0 +1,51 @@
+import { symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolX as symbolTimes, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye } from 'd3-shape';
+export const sqrt3 = Math.sqrt(3);
+export const sqrt4_3 = 2 / sqrt3;
+const symbolHexagon = {
+    draw(context, size) {
+        const rx = Math.sqrt(size / Math.PI), ry = rx * sqrt4_3, hy = ry / 2;
+        context.moveTo(0, ry);
+        context.lineTo(rx, hy);
+        context.lineTo(rx, -hy);
+        context.lineTo(0, -ry);
+        context.lineTo(-rx, -hy);
+        context.lineTo(-rx, hy);
+        context.closePath();
+    }
+};
+const symbols = new Map([
+    ['asterisk', symbolAsterisk],
+    ['circle', symbolCircle],
+    ['cross', symbolCross],
+    ['diamond', symbolDiamond],
+    ['diamond2', symbolDiamond2],
+    ['hexagon', symbolHexagon],
+    ['plus', symbolPlus],
+    ['square', symbolSquare],
+    ['square2', symbolSquare2],
+    ['star', symbolStar],
+    ['times', symbolTimes],
+    ['triangle', symbolTriangle],
+    ['triangle2', symbolTriangle2],
+    ['wye', symbolWye]
+]);
+function isSymbolObject(value) {
+    if (typeof value === 'string')
+        return false;
+    return value && typeof value.draw === 'function';
+}
+export function isSymbol(value) {
+    if (isSymbolObject(value))
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    return symbols.has(value.toLowerCase());
+}
+export function maybeSymbol(symbol) {
+    if (symbol == null || isSymbolObject(symbol))
+        return symbol;
+    const value = symbols.get(`${symbol}`.toLowerCase());
+    if (value)
+        return value;
+    throw new Error(`invalid symbol: ${symbol}`);
+}

package/dist/helpers/typeChecks.d.ts

@@ -0,0 +1,7 @@
+import type { RawValue } from '../types';
+export declare function isBooleanOrNull(v: RawValue): boolean;
+export declare function isDateOrNull(v: RawValue): boolean;
+export declare function isNumberOrNull(v: RawValue): boolean;
+export declare function isStringOrNull(v: RawValue): boolean;
+export declare function isColorOrNull(v: RawValue): boolean;
+export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/helpers/typeChecks.js

@@ -0,0 +1,21 @@
+import chroma from 'chroma-js';
+import { isDate, isFinite } from 'underscore';
+export function isBooleanOrNull(v) {
+    return v == null || typeof v === 'boolean';
+}
+export function isDateOrNull(v) {
+    return v == null || isDate(v);
+}
+export function isNumberOrNull(v) {
+    return v == null || isFinite(v);
+}
+export function isStringOrNull(v) {
+    return v == null || typeof v === 'string';
+}
+export function isColorOrNull(v) {
+    // todo: maybe not use chroma.js here to save kb
+    return v == null || (typeof v === 'string' && chroma.valid(v));
+}
+export function isOpacityOrNull(v) {
+    return v == null || (typeof v === 'number' && isFinite(v) && v >= 0 && v <= 1);
+}

package/dist/helpers/wrapArray.d.ts

@@ -0,0 +1,2 @@
+import type { DataRow } from '../types';
+export default function (data: DataRow[]): (Date | [number, number] | import("../types").DataRecord)[];

package/dist/helpers/wrapArray.js

@@ -0,0 +1,4 @@
+import { isObject } from 'underscore';
+export default function (data) {
+    return data.map((d) => (isObject(d) ? d : { value: d }));
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { default as Dot } from './marks/Dot.svelte';
+export { default as DotX } from './marks/DotX.svelte';
+export { default as DotY } from './marks/DotY.svelte';
+export { default as Plot } from './Plot.svelte';
+export { default as Frame } from './marks/Frame.svelte';
+export { default as GridX } from './marks/GridX.svelte';
+export { default as GridY } from './marks/GridY.svelte';
+export { default as Line } from './marks/Line.svelte';
+export { default as LineX } from './marks/LineX.svelte';
+export { default as LineY } from './marks/LineY.svelte';
+export { default as RuleX } from './marks/RuleX.svelte';
+export { default as RuleY } from './marks/RuleY.svelte';

package/dist/index.js

@@ -0,0 +1,13 @@
+// Reexport your entry components here
+export { default as Dot } from './marks/Dot.svelte';
+export { default as DotX } from './marks/DotX.svelte';
+export { default as DotY } from './marks/DotY.svelte';
+export { default as Plot } from './Plot.svelte';
+export { default as Frame } from './marks/Frame.svelte';
+export { default as GridX } from './marks/GridX.svelte';
+export { default as GridY } from './marks/GridY.svelte';
+export { default as Line } from './marks/Line.svelte';
+export { default as LineX } from './marks/LineX.svelte';
+export { default as LineY } from './marks/LineY.svelte';
+export { default as RuleX } from './marks/RuleX.svelte';
+export { default as RuleY } from './marks/RuleY.svelte';

package/dist/marks/AxisX.svelte

@@ -0,0 +1,101 @@
+<script>import { getContext } from "svelte";
+import BaseMark from "./BaseMark.svelte";
+import resolveChannel from "../helpers/resolveChannel";
+import getBaseStyles from "../helpers/getBaseStyles";
+import removeIdenticalLines from "../helpers/removeIdenticalLines";
+import autoTimeFormat from "../helpers/autoTimeFormat";
+import dayjs from "dayjs";
+import { get } from "underscore";
+const BaseMark_AxisX = BaseMark;
+const plot = getContext("svelteplot");
+let {
+  ticks = [],
+  anchor = "bottom",
+  tickSize = 6,
+  tickPadding = 3,
+  tickFormat = null,
+  automatic = false,
+  title = null,
+  tickFontSize = null,
+  fill = null,
+  ...styleProps
+} = $props();
+let autoTickCount = $derived(plot.plotWidth / get(plot, "options.x.tickSpacing", 80));
+let autoTicks = $derived(
+  ticks.length > 0 ? ticks : get(plot, "options.x.ticks", plot.xScale.ticks(autoTickCount))
+);
+let useTickFormat = $derived(
+  typeof tickFormat === "function" ? tickFormat : plot.x.scaleType === "time" ? typeof tickFormat === "string" ? (d) => dayjs(d).format(tickFormat).split("\n") : autoTimeFormat(plot.x, plot.plotWidth) : (d) => String(d)
+);
+let tickTexts = $derived(
+  removeIdenticalLines(
+    autoTicks.map(useTickFormat).map((tick) => Array.isArray(tick) ? tick : [tick])
+  )
+);
+let optionsLabel = $derived(plot.options?.x?.label);
+let useTitle = $derived(
+  title || (optionsLabel === null ? null : optionsLabel === void 0 ? plot.x.autoTitle : optionsLabel)
+);
+</script>
+
+<BaseMark_AxisX type="axis-x" data={ticks} channels={['x']} {automatic}>
+    <g class="axis-x">
+        {#if useTitle}
+            <text
+                x={plot.plotWidth + plot.margins.left}
+                y={plot.height - 10}
+                class="axis-title"
+                dominant-baseline="hanging">{useTitle} →</text
+            >
+        {/if}
+        {#each autoTicks as tick, t}
+            {@const textLines = tickTexts[t]}
+            {@const prevTextLines = t && tickTexts[t - 1]}
+            <g
+                class="x-tick"
+                transform="translate({plot.xScale(tick)},{anchor === 'bottom'
+                    ? plot.margins.top + plot.plotHeight
+                    : plot.margins.top})"
+            >
+                <text
+                    style={getBaseStyles(tick, { fill, fontSize: tickFontSize })}
+                    y={(tickSize + tickPadding) * (anchor === 'bottom' ? 1 : -1)}
+                    dominant-baseline={anchor === 'bottom' ? 'hanging' : 'auto'}
+                >
+                    {#if typeof textLines === 'string' || textLines.length === 1}
+                        {textLines}
+                    {:else}
+                        {#each textLines as line, i}
+                            <tspan x="0" dy={i ? 12 : 0}
+                                >{!prevTextLines || prevTextLines[i] !== line ? line : ''}</tspan
+                            >
+                        {/each}
+                    {/if}
+                </text>
+                <line
+                    style={getBaseStyles(tick, styleProps)}
+                    y2={anchor === 'bottom' ? tickSize : -tickSize}
+                />
+            </g>
+        {/each}
+    </g>
+</BaseMark_AxisX>
+
+<style>
+    text {
+        text-anchor: middle;
+        font-size: 11px;
+
+        fill: #4a4a4a;
+    }
+
+    text.axis-title {
+        text-anchor: end;
+    }
+    .x-tick line {
+        stroke: currentColor;
+    }
+    .x-tick line.grid {
+        stroke: #d9d9d9;
+    }
+</style>

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

@@ -0,0 +1,17 @@
+import { SvelteComponent } from "svelte";
+import type { AxisMarkOptions } from '../types';
+declare const __propDef: {
+    props: AxisMarkOptions & {
+        anchor?: "bottom" | "top" | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type AxisXProps = typeof __propDef.props;
+export type AxisXEvents = typeof __propDef.events;
+export type AxisXSlots = typeof __propDef.slots;
+export default class AxisX extends SvelteComponent<AxisXProps, AxisXEvents, AxisXSlots> {
+}
+export {};

package/dist/marks/AxisY.svelte

@@ -0,0 +1,69 @@
+<script>import { getContext } from "svelte";
+import BaseMark from "./BaseMark.svelte";
+import getBaseStyles from "../helpers/getBaseStyles";
+import { get } from "underscore";
+const BaseMark_AxisX = BaseMark;
+const plot = getContext("svelteplot");
+let {
+  ticks = [],
+  anchor = "left",
+  automatic = false,
+  tickSize = 6,
+  tickPadding = 3,
+  title = null,
+  tickFormat = (d) => String(d),
+  tickFontSize = null,
+  fill = null,
+  ...styleProps
+} = $props();
+let autoTickCount = $derived(plot.plotHeight / get(plot, "options.y.tickSpacing", 80));
+let autoTicks = $derived(
+  ticks.length > 0 ? ticks : get(plot, "options.y.ticks", plot.yScale.ticks(autoTickCount))
+);
+let optionsLabel = $derived(get(plot, "options.y.label"));
+let useTitle = $derived(
+  title || (optionsLabel === null ? null : optionsLabel === void 0 ? plot.y.autoTitle : optionsLabel)
+);
+</script>
+
+<BaseMark_AxisX type="axis-y" data={ticks} channels={['y']} {automatic}>
+    <g class="axis-y">
+        {#if useTitle}
+            <text x={0} y={5} class="axis-title" dominant-baseline="hanging">↑ {useTitle}</text>
+        {/if}
+        {#each autoTicks as tick}
+            <g
+                class="y-tick"
+                transform="translate({plot.margins.left +
+                    (anchor === 'left' ? 0 : plot.plotWidth)},{plot.yScale(tick)})"
+            >
+                <text
+                    class:is-left={anchor === 'left'}
+                    style={getBaseStyles(tick, { fill, fontSize: tickFontSize })}
+                    x={(tickSize + tickPadding) * (anchor === 'left' ? -1 : 1)}
+                    dominant-baseline="middle">{tickFormat(tick)}</text
+                >
+                <line
+                    style={getBaseStyles(tick, styleProps)}
+                    x2={anchor === 'left' ? -tickSize : tickSize}
+                />
+            </g>
+        {/each}
+    </g>
+</BaseMark_AxisX>
+
+<style>
+    text {
+        font-size: 11px;
+        fill: #4a4a4a;
+    }
+    text.is-left {
+        text-anchor: end;
+    }
+    text.axis-title {
+        text-anchor: start;
+    }
+    .y-tick line {
+        stroke: currentColor;
+    }
+</style>

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

@@ -0,0 +1,15 @@
+import { SvelteComponent } from "svelte";
+import type { AxisYMarkProps } from '../types';
+declare const __propDef: {
+    props: AxisYMarkProps;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type AxisYProps = typeof __propDef.props;
+export type AxisYEvents = typeof __propDef.events;
+export type AxisYSlots = typeof __propDef.slots;
+export default class AxisY extends SvelteComponent<AxisYProps, AxisYEvents, AxisYSlots> {
+}
+export {};

package/dist/marks/BaseMark.svelte

@@ -0,0 +1,22 @@
+<script context="module"></script>
+
+<script generics="T extends BaseMarkProps">import { Mark } from "../classes/Mark.svelte";
+import { getContext } from "svelte";
+const plot = getContext("svelteplot");
+let { type, data = [], channels = [], children, automatic, ...rest } = $props();
+const mark = new Mark(type, channels, automatic, { data, ...rest });
+plot.addMark(mark);
+$effect(() => {
+  mark.channels = new Set(channels);
+});
+$effect(() => {
+  mark.props = { data, ...rest };
+});
+$effect(() => {
+  return () => {
+    plot.removeMark(mark);
+  };
+});
+</script>
+
+<slot />

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

@@ -0,0 +1,19 @@
+import { SvelteComponent } from "svelte";
+import type { BaseMarkProps } from '../types';
+declare class __sveltets_Render<T extends BaseMarkProps> {
+    props(): T & {
+        children?: Function | undefined;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {
+        default: {};
+    };
+}
+export type BaseMarkProps<T extends BaseMarkProps> = ReturnType<__sveltets_Render<T>['props']>;
+export type BaseMarkEvents<T extends BaseMarkProps> = ReturnType<__sveltets_Render<T>['events']>;
+export type BaseMarkSlots<T extends BaseMarkProps> = ReturnType<__sveltets_Render<T>['slots']>;
+export default class BaseMark<T extends BaseMarkProps> extends SvelteComponent<BaseMarkProps<T>, BaseMarkEvents<T>, BaseMarkSlots<T>> {
+}
+export {};