@faintshadow/flarecharts 26.3.1

package/dist/core/stack.d.ts

@@ -0,0 +1,19 @@
+import type { NormalizedPoint, XValue } from './normalize.js';
+export interface StackInput<K = number> {
+    /** Caller's identifier for the series (flarechart uses the registration index). */
+    key: K;
+    points: readonly NormalizedPoint<unknown>[];
+}
+/** xKey (see stackKey) → [y0, y1] extents in VALUE space. */
+export type StackExtents = Map<string, [number, number]>;
+/** How the stack sits. normal/percent anchor at zero; stream/silhouette float. */
+export type StackOffset = 'normal' | 'percent' | 'stream' | 'silhouette' | 'none';
+/** Layer ordering within the stack. */
+export type StackOrder = 'none' | 'ascending' | 'descending' | 'inside-out' | 'reverse' | 'appearance';
+export interface StackOptions {
+    offset?: StackOffset;
+    order?: StackOrder;
+}
+/** Canonical map key for an x value — Date-safe (equal instants collide). */
+export declare function stackKey(x: XValue): string;
+export declare function stackSeries<K>(series: readonly StackInput<K>[], options?: StackOptions): Map<K, StackExtents>;

package/dist/core/stack.js

@@ -0,0 +1,133 @@
+/**
+ * Stacking math — a first-class, configurable primitive over d3-shape's stack().
+ *
+ * Like d3, stacking is its own thing here: pick an OFFSET (how the stack sits)
+ * and an ORDER (the layer sequence). d3.stack() does the cumulative work; two
+ * adapter concerns wrap it to fit flarechart's data model:
+ *
+ *  1. Pivot — the library stores column-oriented, ragged, gappy
+ *     NormalizedPoint[] per series; d3.stack wants a rectangular table (one row
+ *     per x, one column per series). We union the x keys (Date-safe stackKey),
+ *     build rows, feed gap/absent cells as 0 so they take no part, then drop
+ *     them from the output (no entry → no bar / area break, no hole).
+ *  2. Percent — d3's stackOffsetExpand normalizes by the signed row total; we
+ *     instead pre-scale values to ±100 against separate positive/negative
+ *     totals before the diverging offset.
+ *
+ * Offsets:
+ *   normal     → diverging (positives up, negatives down from zero)
+ *   percent    → ±100 pre-scale, then diverging
+ *   stream     → wiggle (streamgraph — floats, minimized movement)
+ *   silhouette → centered around zero (floats)
+ *   none       → plain cumulative from zero (sign-naive)
+ *
+ * Output stays in the library's [base, base+value] convention for the diverging
+ * offsets (a negative reads [0, -4], not d3's [-4, 0]); the floating offsets
+ * (stream/silhouette/none) pass d3's [lower, upper] through unchanged.
+ */
+import { stack as d3stack, stackOffsetDiverging, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse } from 'd3-shape';
+/** Canonical map key for an x value — Date-safe (equal instants collide). */
+export function stackKey(x) {
+    return x instanceof Date ? `t${x.getTime()}` : String(x);
+}
+const OFFSETS = {
+    normal: stackOffsetDiverging,
+    percent: stackOffsetDiverging,
+    stream: stackOffsetWiggle,
+    silhouette: stackOffsetSilhouette,
+    none: stackOffsetNone
+};
+const ORDERS = {
+    none: stackOrderNone,
+    ascending: stackOrderAscending,
+    descending: stackOrderDescending,
+    'inside-out': stackOrderInsideOut,
+    reverse: stackOrderReverse,
+    appearance: stackOrderAppearance
+};
+export function stackSeries(series, options = {}) {
+    const offset = options.offset ?? 'normal';
+    const order = options.order ?? 'none';
+    // The [base, base+value] orientation flip only applies to the diverging
+    // offsets; the floating offsets emit d3's [lower, upper] directly.
+    const diverging = offset === 'normal' || offset === 'percent';
+    const out = new Map();
+    if (series.length === 0)
+        return out;
+    // Union of x keys in first-seen order, plus a per-series cell table.
+    // A cell is a gap until some non-null point fills it; duplicate points at
+    // the same x within a series sum (matching the previous accumulation).
+    const keyOrder = [];
+    const seen = new Set();
+    const cells = series.map((s) => {
+        const m = new Map();
+        for (const p of s.points) {
+            const k = stackKey(p.x);
+            if (!seen.has(k)) {
+                seen.add(k);
+                keyOrder.push(k);
+            }
+            const cur = m.get(k) ?? { value: 0, gap: true };
+            if (p.y != null) {
+                cur.value += p.y;
+                cur.gap = false;
+            }
+            m.set(k, cur);
+        }
+        return m;
+    });
+    // Percent: pre-scale to ±100 against separate positive/negative totals, so
+    // positives fill 0..100 and negatives 0..-100 independently at each x.
+    if (offset === 'percent') {
+        const posTotals = new Map();
+        const negTotals = new Map();
+        for (const m of cells) {
+            for (const [k, c] of m) {
+                if (c.gap)
+                    continue;
+                if (c.value >= 0)
+                    posTotals.set(k, (posTotals.get(k) ?? 0) + c.value);
+                else
+                    negTotals.set(k, (negTotals.get(k) ?? 0) + Math.abs(c.value));
+            }
+        }
+        for (const m of cells) {
+            for (const [k, c] of m) {
+                if (c.gap)
+                    continue;
+                const total = c.value >= 0 ? posTotals.get(k) : negTotals.get(k);
+                c.value = !total ? 0 : (c.value / total) * 100;
+            }
+        }
+    }
+    // Pivot to a rectangular table keyed by series index; gaps contribute 0.
+    const idxKeys = series.map((_, i) => String(i));
+    const rows = keyOrder.map((xKey) => {
+        const row = {};
+        cells.forEach((m, i) => {
+            const c = m.get(xKey);
+            row[String(i)] = c && !c.gap ? c.value : 0;
+        });
+        return row;
+    });
+    const stacked = d3stack()
+        .keys(idxKeys)
+        .value((row, key) => row[key] ?? 0)
+        .order(ORDERS[order])
+        .offset(OFFSETS[offset])(rows);
+    // Map back: drop gap cells; flip negatives to [base, base+value] for the
+    // diverging offsets (d3 emits [lower, upper]).
+    stacked.forEach((layer, i) => {
+        const extents = new Map();
+        const m = cells[i];
+        layer.forEach((pt, rowIdx) => {
+            const xKey = keyOrder[rowIdx];
+            const c = m.get(xKey);
+            if (!c || c.gap)
+                return;
+            extents.set(xKey, diverging && c.value < 0 ? [pt[1], pt[0]] : [pt[0], pt[1]]);
+        });
+        out.set(series[i].key, extents);
+    });
+    return out;
+}

package/dist/core/stats.d.ts

@@ -0,0 +1,45 @@
+export interface FiveNumber {
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+}
+/** Five-number summary from raw samples, or null if there are no finite values. */
+export declare function fiveNumber(samples: readonly number[]): FiveNumber | null;
+export interface BoxStats {
+    q1: number;
+    median: number;
+    q3: number;
+    /** Whisker ends — Tukey-clamped or data min/max per `whisker`. */
+    low: number;
+    high: number;
+    /** Samples outside the whiskers (always empty for 'minmax'). */
+    outliers: number[];
+}
+export type WhiskerMode = 'tukey' | 'minmax';
+/** Full box statistics from raw samples, or null if there are no finite values. */
+export declare function boxStats(samples: readonly number[], options?: {
+    whisker?: WhiskerMode;
+    k?: number;
+}): BoxStats | null;
+export interface BoxAccessors<T = unknown> {
+    low?: (datum: T, index: number) => number | null | undefined;
+    q1?: (datum: T, index: number) => number | null | undefined;
+    median?: (datum: T, index: number) => number | null | undefined;
+    q3?: (datum: T, index: number) => number | null | undefined;
+    high?: (datum: T, index: number) => number | null | undefined;
+    outliers?: (datum: T, index: number) => readonly number[] | undefined;
+    samples?: (datum: T, index: number) => readonly number[] | undefined;
+}
+/**
+ * Resolve one datum to BoxStats. Precedence:
+ *   1. `samples` accessor → boxStats(samples)
+ *   2. precomputed accessors (low/q1/median/q3/high[/outliers])
+ *   3. inferred from datum shape: 5-/6-tuple or { low,q1,median,q3,high,outliers? }
+ * Returns null if a required value is missing or non-finite.
+ */
+export declare function resolveBoxStats<T>(datum: T, index: number, accessors: BoxAccessors<T>, options?: {
+    whisker?: WhiskerMode;
+    k?: number;
+}): BoxStats | null;

package/dist/core/stats.js

@@ -0,0 +1,114 @@
+/**
+ * Box-plot statistics — pure, DOM-free, Vitest-tested (like stack.ts / hit.ts).
+ * The only d3 touched here is d3-array's `quantileSorted` (math only).
+ */
+import { quantileSorted } from 'd3-array';
+/** Drop non-finite values and return a sorted copy. */
+function clean(samples) {
+    const out = [];
+    for (const v of samples) {
+        if (typeof v === 'number' && Number.isFinite(v))
+            out.push(v);
+    }
+    out.sort((a, b) => a - b);
+    return out;
+}
+/** Five-number summary from raw samples, or null if there are no finite values. */
+export function fiveNumber(samples) {
+    const s = clean(samples);
+    if (s.length === 0)
+        return null;
+    return {
+        min: s[0],
+        q1: quantileSorted(s, 0.25),
+        median: quantileSorted(s, 0.5),
+        q3: quantileSorted(s, 0.75),
+        max: s[s.length - 1]
+    };
+}
+/** Full box statistics from raw samples, or null if there are no finite values. */
+export function boxStats(samples, options = {}) {
+    const s = clean(samples);
+    if (s.length === 0)
+        return null;
+    const { whisker = 'tukey', k = 1.5 } = options;
+    const q1 = quantileSorted(s, 0.25);
+    const median = quantileSorted(s, 0.5);
+    const q3 = quantileSorted(s, 0.75);
+    if (whisker === 'minmax') {
+        return { q1, median, q3, low: s[0], high: s[s.length - 1], outliers: [] };
+    }
+    const iqr = q3 - q1;
+    const loFence = q1 - k * iqr;
+    const hiFence = q3 + k * iqr;
+    // s is sorted: low = first value within the fence, high = last value within it.
+    let low = s[0];
+    for (const v of s) {
+        if (v >= loFence) {
+            low = v;
+            break;
+        }
+    }
+    let high = s[s.length - 1];
+    for (let i = s.length - 1; i >= 0; i--) {
+        if (s[i] <= hiFence) {
+            high = s[i];
+            break;
+        }
+    }
+    const outliers = [];
+    for (const v of s) {
+        if (v < low || v > high)
+            outliers.push(v);
+    }
+    return { q1, median, q3, low, high, outliers };
+}
+const finite = (v) => typeof v === 'number' && Number.isFinite(v) ? v : null;
+const finiteList = (v) => Array.isArray(v) ? v.filter((n) => typeof n === 'number' && Number.isFinite(n)) : [];
+/**
+ * Resolve one datum to BoxStats. Precedence:
+ *   1. `samples` accessor → boxStats(samples)
+ *   2. precomputed accessors (low/q1/median/q3/high[/outliers])
+ *   3. inferred from datum shape: 5-/6-tuple or { low,q1,median,q3,high,outliers? }
+ * Returns null if a required value is missing or non-finite.
+ */
+export function resolveBoxStats(datum, index, accessors, options = {}) {
+    const samples = accessors.samples?.(datum, index);
+    if (samples)
+        return boxStats(samples, options);
+    if (accessors.median || accessors.q1 || accessors.q3) {
+        const q1 = finite(accessors.q1?.(datum, index));
+        const median = finite(accessors.median?.(datum, index));
+        const q3 = finite(accessors.q3?.(datum, index));
+        const low = finite(accessors.low?.(datum, index));
+        const high = finite(accessors.high?.(datum, index));
+        if (q1 == null || median == null || q3 == null || low == null || high == null)
+            return null;
+        return { low, q1, median, q3, high, outliers: finiteList(accessors.outliers?.(datum, index)) };
+    }
+    if (Array.isArray(datum)) {
+        const offset = datum.length >= 6 ? 1 : 0; // 6-tuple => x is at [0]
+        if (datum.length < 5 + offset)
+            return null;
+        const low = finite(datum[offset]);
+        const q1 = finite(datum[offset + 1]);
+        const median = finite(datum[offset + 2]);
+        const q3 = finite(datum[offset + 3]);
+        const high = finite(datum[offset + 4]);
+        if (low == null || q1 == null || median == null || q3 == null || high == null)
+            return null;
+        return { low, q1, median, q3, high, outliers: [] };
+    }
+    if (datum && typeof datum === 'object') {
+        const o = datum;
+        const low = finite(o.low);
+        const q1 = finite(o.q1);
+        const median = finite(o.median);
+        const q3 = finite(o.q3);
+        const high = finite(o.high);
+        if (low == null || q1 == null || median == null || q3 == null || high == null)
+            return null;
+        return { low, q1, median, q3, high, outliers: finiteList(o.outliers) };
+    }
+    return null;
+}

package/dist/core/symbols.d.ts

@@ -0,0 +1,8 @@
+import type { SymbolType } from 'd3-shape';
+export type SymbolName = 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
+/** Resolve a symbol by name, or pass a d3 SymbolType straight through. */
+export declare function symbolFor(symbol?: SymbolName | SymbolType): SymbolType;
+/** Pick a symbol from the default cycle by series index. */
+export declare function symbolByIndex(index: number): SymbolType;
+/** Generate the SVG path `d` string for a symbol at the origin. */
+export declare function symbolPath(type: SymbolType, size?: number): string;

package/dist/core/symbols.js

@@ -0,0 +1,31 @@
+import { symbol as d3symbol, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye } from 'd3-shape';
+const SYMBOLS = {
+    circle: symbolCircle,
+    cross: symbolCross,
+    diamond: symbolDiamond,
+    square: symbolSquare,
+    star: symbolStar,
+    triangle: symbolTriangle,
+    wye: symbolWye
+};
+const SYMBOL_CYCLE = [
+    'circle',
+    'diamond',
+    'square',
+    'triangle',
+    'star',
+    'cross',
+    'wye'
+];
+/** Resolve a symbol by name, or pass a d3 SymbolType straight through. */
+export function symbolFor(symbol = 'circle') {
+    return typeof symbol === 'string' ? SYMBOLS[symbol] : symbol;
+}
+/** Pick a symbol from the default cycle by series index. */
+export function symbolByIndex(index) {
+    return SYMBOLS[SYMBOL_CYCLE[index % SYMBOL_CYCLE.length]];
+}
+/** Generate the SVG path `d` string for a symbol at the origin. */
+export function symbolPath(type, size = 64) {
+    return d3symbol().type(type).size(size)() ?? '';
+}

package/dist/core/types.d.ts

@@ -0,0 +1,28 @@
+import type { ScaleKind } from './scales.js';
+export interface Padding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface AxisOptions {
+    /** Scale type. Omit to infer from data: Date → time, string → band, else linear. */
+    type?: ScaleKind;
+    /** Pin the domain start (continuous scales). Omit/undefined → from data. */
+    min?: number | Date;
+    /** Pin the domain end (continuous scales). Omit/undefined → from data. */
+    max?: number | Date;
+    /** Band scales: explicit category order. Omit → unique x values in data order. */
+    categories?: string[];
+    /** `true` (default) → nice domain; a number → tick count hint; `false` → exact. */
+    nice?: boolean | number;
+    /** Force the domain to include zero (off by default). */
+    includeZero?: boolean;
+    /** Band scales: inner padding ratio (default 0.1). */
+    bandPadding?: number;
+}
+export interface ChartOptions {
+    padding?: Padding;
+    x?: AxisOptions;
+    y?: AxisOptions;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+export { default as Chart } from './components/Chart.svelte';
+export { default as Svg } from './components/Svg.svelte';
+export { default as Axis } from './components/Axis.svelte';
+export { default as Grid } from './components/Grid.svelte';
+export { default as Line } from './components/Line.svelte';
+export { default as Area } from './components/Area.svelte';
+export { default as Points } from './components/Points.svelte';
+export { default as Bars } from './components/Bars.svelte';
+export { default as PlotBand } from './components/PlotBand.svelte';
+export { default as PlotLine } from './components/PlotLine.svelte';
+export { default as Tooltip } from './components/Tooltip.svelte';
+export { default as Crosshair } from './components/Crosshair.svelte';
+export { default as Legend } from './components/Legend.svelte';
+export { default as Arc } from './components/Arc.svelte';
+export { default as Labels } from './components/Labels.svelte';
+export { default as Box } from './components/Box.svelte';
+export { default as Sparkline } from './charts/Sparkline.svelte';
+export { default as LineChart } from './charts/LineChart.svelte';
+export { default as AreaChart } from './charts/AreaChart.svelte';
+export { default as BarChart } from './charts/BarChart.svelte';
+export { default as DonutChart } from './charts/DonutChart.svelte';
+export { default as StackChart } from './charts/StackChart.svelte';
+export { default as BoxPlotChart } from './charts/BoxPlotChart.svelte';
+export { ChartContext, getChartContext, setChartContext } from './core/context.svelte.js';
+export type { RegisteredSeries, SeriesEntry, SeriesRegistration, StackedSeriesOptions } from './core/context.svelte.js';
+export { stackKey, stackSeries } from './core/stack.js';
+export type { StackExtents, StackInput, StackOffset, StackOptions, StackOrder } from './core/stack.js';
+export { placeLabels } from './core/labels.js';
+export type { LabelCandidate, LabelPlacementOptions, PlacedLabel } from './core/labels.js';
+export { SERIES_DEFAULTS, resolveSeries, splitAxisOptions } from './core/options.js';
+export type { BandSpec, LegendSpec, PlotLineSpec, PlotOptions, ResolvedSeries, SeriesOptions, MarkerMode, SimpleAxisOptions, TooltipSpec } from './core/options.js';
+export { applyResponsive } from './core/responsive.js';
+export type { ResponsiveRule } from './core/responsive.js';
+export { moveFocus } from './core/keynav.js';
+export type { KeyNavPosition, KeyNavSeries } from './core/keynav.js';
+export { bisectNearest } from './core/bisect.js';
+export { hitBisectX, hitNearest, hitsAtBand } from './core/hit.js';
+export type { HitResult, TooltipData, TooltipMode, TooltipPoint } from './core/hit.js';
+export { normalizePoints, xKindOf } from './core/normalize.js';
+export type { NormalizedPoint, PointAccessors, XValue } from './core/normalize.js';
+export { mergeOptions } from './core/merge.js';
+export { bandInvert, createScale, isBandScale, scalePos, scaleTicks, scaleTickFormat } from './core/scales.js';
+export type { AnyScale, ScaleDomain, ScaleKind, ScaleSpec } from './core/scales.js';
+export { curveFor } from './core/curves.js';
+export type { CurveName } from './core/curves.js';
+export { symbolFor, symbolByIndex, symbolPath } from './core/symbols.js';
+export type { SymbolName } from './core/symbols.js';
+export { DEFAULT_PALETTE, seriesColorVar } from './core/palette.js';
+export { fiveNumber, boxStats, resolveBoxStats } from './core/stats.js';
+export type { FiveNumber, BoxStats, WhiskerMode, BoxAccessors } from './core/stats.js';
+export { prefersReducedMotion, parseDuration, motionDuration, boxEnterPhases } from './core/motion.svelte.js';
+export type { AxisOptions, ChartOptions, Padding } from './core/types.js';

package/dist/index.js

@@ -0,0 +1,42 @@
+// L1 primitives
+export { default as Chart } from './components/Chart.svelte';
+export { default as Svg } from './components/Svg.svelte';
+export { default as Axis } from './components/Axis.svelte';
+export { default as Grid } from './components/Grid.svelte';
+export { default as Line } from './components/Line.svelte';
+export { default as Area } from './components/Area.svelte';
+export { default as Points } from './components/Points.svelte';
+export { default as Bars } from './components/Bars.svelte';
+export { default as PlotBand } from './components/PlotBand.svelte';
+export { default as PlotLine } from './components/PlotLine.svelte';
+export { default as Tooltip } from './components/Tooltip.svelte';
+export { default as Crosshair } from './components/Crosshair.svelte';
+export { default as Legend } from './components/Legend.svelte';
+export { default as Arc } from './components/Arc.svelte';
+export { default as Labels } from './components/Labels.svelte';
+export { default as Box } from './components/Box.svelte';
+// L2 simple charts (built only from L1)
+export { default as Sparkline } from './charts/Sparkline.svelte';
+export { default as LineChart } from './charts/LineChart.svelte';
+export { default as AreaChart } from './charts/AreaChart.svelte';
+export { default as BarChart } from './charts/BarChart.svelte';
+export { default as DonutChart } from './charts/DonutChart.svelte';
+export { default as StackChart } from './charts/StackChart.svelte';
+export { default as BoxPlotChart } from './charts/BoxPlotChart.svelte';
+// Core (the math under the components — public, tested, tree-shakeable)
+export { ChartContext, getChartContext, setChartContext } from './core/context.svelte.js';
+export { stackKey, stackSeries } from './core/stack.js';
+export { placeLabels } from './core/labels.js';
+export { SERIES_DEFAULTS, resolveSeries, splitAxisOptions } from './core/options.js';
+export { applyResponsive } from './core/responsive.js';
+export { moveFocus } from './core/keynav.js';
+export { bisectNearest } from './core/bisect.js';
+export { hitBisectX, hitNearest, hitsAtBand } from './core/hit.js';
+export { normalizePoints, xKindOf } from './core/normalize.js';
+export { mergeOptions } from './core/merge.js';
+export { bandInvert, createScale, isBandScale, scalePos, scaleTicks, scaleTickFormat } from './core/scales.js';
+export { curveFor } from './core/curves.js';
+export { symbolFor, symbolByIndex, symbolPath } from './core/symbols.js';
+export { DEFAULT_PALETTE, seriesColorVar } from './core/palette.js';
+export { fiveNumber, boxStats, resolveBoxStats } from './core/stats.js';
+export { prefersReducedMotion, parseDuration, motionDuration, boxEnterPhases } from './core/motion.svelte.js';

package/package.json

@@ -0,0 +1,81 @@
+{
+	"name": "@faintshadow/flarecharts",
+	"version": "26.3.1",
+	"description": "Composable, runes-first SVG charting library for Svelte 5. CSS-variable theming, typed snippets, accessible by default.",
+	"license": "SEE LICENSE IN LICENSE",
+	"author": "Safwen TBINI <https://form.typeform.com/to/HjsO4h0K>",
+	"homepage": "https://faintshadow.gitlab.io/flarecharts/",
+	"repository": {
+		"type": "git",
+		"url": "git+https://gitlab.com/FaintShadow/flarecharts.git"
+	},
+	"bugs": {
+		"url": "https://gitlab.com/FaintShadow/flarecharts/-/boards"
+	},
+	"type": "module",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"prepare": "svelte-kit sync",
+		"version:stamp": "node scripts/version-stamp.mjs"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"sideEffects": false,
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.0.0"
+	},
+	"dependencies": {
+		"d3-array": "^3.2.4",
+		"d3-interpolate-path": "^2.3.0",
+		"d3-scale": "^4.0.2",
+		"d3-shape": "^3.2.0",
+		"d3-time": "^3.1.0"
+	},
+	"devDependencies": {
+		"@sveltejs/adapter-auto": "^3.3.1",
+		"@sveltejs/adapter-static": "^3.0.10",
+		"@sveltejs/kit": "^2.20.0",
+		"@sveltejs/package": "^2.3.10",
+		"@sveltejs/vite-plugin-svelte": "^5.0.0",
+		"@types/d3-array": "^3.2.1",
+		"@types/d3-interpolate-path": "^2.0.3",
+		"@types/d3-scale": "^4.0.9",
+		"@types/d3-shape": "^3.1.7",
+		"@types/d3-time": "^3.0.4",
+		"@types/node": "^22.0.0",
+		"publint": "^0.3.0",
+		"svelte": "^5.30.0",
+		"svelte-check": "^4.1.0",
+		"typescript": "^5.8.0",
+		"vite": "^6.2.0",
+		"vitest": "^3.1.0"
+	},
+	"keywords": [
+		"svelte",
+		"svelte5",
+		"charts",
+		"charting",
+		"svg",
+		"dataviz",
+		"runes"
+	]
+}