@misoto22/folio 0.0.0 → 0.16.0

package/dist/charts/lib/paint.d.ts

@@ -0,0 +1,154 @@
+import * as react from 'react';
+import { ChartConfig } from './chart.js';
+import 'recharts';
+
+/**
+ * The intro wipe's direction, shared by every mark that has one.
+ *
+ * Named for the DATA rather than for the screen. `forward` runs from the first
+ * row to the last, `reverse` the other way — which is the thing the author
+ * actually means, and stays true in a right-to-left document, where a cartesian
+ * plot is still drawn first-row-first.
+ *
+ * `"none"` opts out, and is also what a device with the OS reduce-motion
+ * preference falls back to: a reveal is a per-frame animated SVG mask, the
+ * heaviest thing in the package and the least welcome to a reader who has
+ * asked for stillness.
+ */
+type ChartRevealType = 'none' | 'forward' | 'reverse' | 'center-out' | 'edges-in';
+/** A reveal that actually plays. */
+type ChartRevealDirection = Exclude<ChartRevealType, 'none'>;
+/** The intro wipe, in seconds. */
+declare const REVEAL_DURATION = 1;
+/**
+ * The wipe's curve. Not `--ease`: the system's easing is tuned for a control
+ * moving a few pixels, and over a full plot width it arrives too abruptly.
+ * A long, flat tail is what makes a line read as being drawn.
+ */
+declare const REVEAL_EASE: [number, number, number, number];
+/**
+ * The mask that draws a line or an area in.
+ *
+ * One mask covers the mark's fill, its stroke AND its resting dots, so the
+ * three arrive together. Drawn separately — which is what Recharts' own
+ * animation does — the dots pop in before the line reaches them.
+ *
+ * Both `maskUnits` and `maskContentUnits` are user space so every masked
+ * element shares one coordinate system and the wipe edge lands at the same x
+ * on each of them.
+ */
+declare function RevealMask({ id, type }: {
+    id: string;
+    type: ChartRevealDirection;
+}): react.JSX.Element;
+interface PaintProps {
+    /** The owning mark's id, which scopes every definition below. */
+    id: string;
+    /** The series being painted. */
+    dataKey: string;
+}
+/**
+ * The one gradient everything else is masked out of.
+ *
+ * Every fill variant, every stroke and every dot in a chart paints from this,
+ * which is what makes a series a single visual object rather than a set of
+ * elements that happen to share a colour. A series with one colour still gets a
+ * two-stop gradient: it keeps the paint reference identical across variants, so
+ * switching a series from one colour to three changes no other code.
+ */
+declare function SeriesGradient({ id, dataKey, config, direction, gradientUnits, }: PaintProps & {
+    config: ChartConfig;
+    /** Horizontal reads along the axis; vertical reads up the mark. */
+    direction?: 'horizontal' | 'vertical';
+    gradientUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+}): react.JSX.Element;
+/**
+ * The stops themselves, so a variant can build its own gradient from them.
+ *
+ * `opacities` ramps the stops independently of their colour — a radar's fill
+ * fades from its centre outward without needing a second gradient to mask it.
+ */
+declare function ColorStops({ dataKey, stops, opacities, }: {
+    dataKey: string;
+    stops: number;
+    opacities?: number[];
+}): react.JSX.Element;
+/** Solid at the top, dissolving toward the axis. The default. */
+declare function AreaGradientFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** The same fade, run the other way — heavier where it meets the axis. */
+declare function AreaGradientReverseFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** One flat wash, no fade. Reads as a band rather than as a slope. */
+declare function AreaSolidFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** A field of dots. The lightest texture, and the one that stacks best. */
+declare function AreaDottedFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** Diagonal rule lines, 45°. */
+declare function AreaLinesFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** Wide soft-edged stripes at 20°. The heaviest of the six. */
+declare function AreaHatchedFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/**
+ * What a series looks like when another one is selected.
+ *
+ * A thin diagonal rule rather than a lower opacity: opacity alone makes a
+ * series faint, and a faint area on a white ground is still an area. The
+ * texture change is what makes it read as "not this one".
+ */
+declare function UnselectedFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/** 45° stripes over a faint ground. */
+declare function BarHatchedFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/**
+ * Stripes with nothing behind them — the projected, not-yet-real part of a
+ * series. Used by the last bar when `buffer` is set.
+ */
+declare function BarBufferFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/**
+ * A bar split down its own middle, one half at full weight.
+ *
+ * Everything here is in object-bounding-box units so the split lands at each
+ * bar's centre rather than at the plot's — in user space a narrow bar at the
+ * right of the chart would be entirely on one side of the seam.
+ */
+declare function BarDuotoneFill({ id, dataKey, config, reverse, }: PaintProps & {
+    config: ChartConfig;
+    reverse?: boolean;
+}): react.JSX.Element;
+/** Solid at the top of the bar, dissolving toward the baseline. */
+declare function BarGradientFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/**
+ * A faint body under a solid cap, drawn by the bar shape itself.
+ *
+ * The variant that survives density best: at twenty bars a solid block becomes
+ * a wall, and a 2px cap over a wash still reads as twenty distinct values.
+ */
+declare function BarStrippedFill({ id, dataKey }: PaintProps): react.JSX.Element;
+/**
+ * The halo behind a highlighted mark.
+ *
+ * The one blur in the package, and it is a filter on a MARK rather than a
+ * box-shadow under a panel — law 2 bans the second, not the first. It exists
+ * because a monochrome chart has no "brighter" to reach for when one series has
+ * to be the point of the figure.
+ *
+ * A line needs a wider, stronger halo than a bar: a 0.8px stroke has almost no
+ * area to bleed from, where a bar has its whole face.
+ */
+declare function GlowFilter({ id, dataKey, spread, intensity, }: PaintProps & {
+    /** Blur radius, in user units. */
+    spread?: number;
+    /** Alpha multiplier on the blurred copy. Above 1 saturates it. */
+    intensity?: number;
+}): react.JSX.Element;
+/**
+ * A dashed stroke that crawls along its own path.
+ *
+ * SMIL rather than CSS, because the two attributes have to stay in lockstep and
+ * a CSS animation on `stroke-dasharray` is not interpolated the same way in
+ * every engine. It is composed as a CHILD of the mark, so a caller that does
+ * not ask for it pays nothing — and `keyframes.css`'s reduced-motion rule
+ * cannot reach SMIL, which is why the call sites gate it on `useReducedMotion`
+ * instead.
+ */
+declare function AnimatedDashedStroke({ dash }: {
+    dash?: number;
+}): react.JSX.Element;
+
+export { AnimatedDashedStroke, AreaDottedFill, AreaGradientFill, AreaGradientReverseFill, AreaHatchedFill, AreaLinesFill, AreaSolidFill, BarBufferFill, BarDuotoneFill, BarGradientFill, BarHatchedFill, BarStrippedFill, type ChartRevealDirection, type ChartRevealType, ColorStops, GlowFilter, type PaintProps, REVEAL_DURATION, REVEAL_EASE, RevealMask, SeriesGradient, UnselectedFill };

package/dist/charts/lib/paint.js

@@ -0,0 +1,551 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { motion } from "motion/react";
+import { colorStops } from "./chart.js";
+const REVEAL_DURATION = 1;
+const REVEAL_EASE = [0, 0.7, 0.5, 1];
+const REVEAL_ORIGIN = {
+  forward: 0,
+  reverse: 1,
+  "center-out": 0.5
+};
+function RevealMask({ id, type }) {
+  const reveal = {
+    initial: { scaleX: 0 },
+    animate: { scaleX: 1 },
+    transition: { duration: REVEAL_DURATION, ease: REVEAL_EASE }
+  };
+  return /* @__PURE__ */ jsx(
+    "mask",
+    {
+      id: `${id}-reveal-mask`,
+      maskUnits: "userSpaceOnUse",
+      maskContentUnits: "userSpaceOnUse",
+      x: "0",
+      y: "0",
+      width: "100%",
+      height: "100%",
+      children: type === "edges-in" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          motion.rect,
+          {
+            ...reveal,
+            x: "0",
+            y: "0",
+            width: "50%",
+            height: "100%",
+            fill: "white",
+            style: { originX: 0 }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          motion.rect,
+          {
+            ...reveal,
+            x: "50%",
+            y: "0",
+            width: "50%",
+            height: "100%",
+            fill: "white",
+            style: { originX: 1 }
+          }
+        )
+      ] }) : /* @__PURE__ */ jsx(
+        motion.rect,
+        {
+          ...reveal,
+          x: "0",
+          y: "0",
+          width: "100%",
+          height: "100%",
+          fill: "white",
+          style: { originX: REVEAL_ORIGIN[type] }
+        }
+      )
+    }
+  );
+}
+function SeriesGradient({
+  id,
+  dataKey,
+  config,
+  direction = "horizontal",
+  gradientUnits
+}) {
+  const stops = colorStops(config[dataKey]);
+  const axis = direction === "vertical" ? { x1: "0", y1: "0", x2: "0", y2: "1" } : { x1: "0", y1: "0", x2: "1", y2: "0" };
+  return /* @__PURE__ */ jsx("linearGradient", { id: `${id}-colors-${dataKey}`, ...axis, gradientUnits, children: /* @__PURE__ */ jsx(ColorStops, { dataKey, stops }) });
+}
+function ColorStops({
+  dataKey,
+  stops,
+  opacities
+}) {
+  if (stops === 1) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: `var(--color-${dataKey}-0)`, stopOpacity: opacities?.[0] }),
+      /* @__PURE__ */ jsx(
+        "stop",
+        {
+          offset: "100%",
+          stopColor: `var(--color-${dataKey}-0)`,
+          stopOpacity: opacities?.[opacities.length - 1]
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: Array.from({ length: stops }, (_, index) => {
+    const offset = `${index / (stops - 1) * 100}%`;
+    return /* @__PURE__ */ jsx(
+      "stop",
+      {
+        offset,
+        stopColor: `var(--color-${dataKey}-${index}, var(--color-${dataKey}-0))`,
+        stopOpacity: opacities?.[index]
+      },
+      offset
+    );
+  }) });
+}
+function MaskedFill({
+  name,
+  id,
+  dataKey,
+  texture,
+  patternUnits = "userSpaceOnUse",
+  patternContentUnits,
+  size = { width: "100%", height: "100%" },
+  maskContentUnits,
+  fill
+}) {
+  const maskId = `${id}-${name}-mask-${dataKey}`;
+  const paint = fill ?? `url(#${id}-colors-${dataKey})`;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("mask", { id: maskId, maskContentUnits, children: texture }),
+    /* @__PURE__ */ jsx(
+      "pattern",
+      {
+        id: `${id}-${name}-${dataKey}`,
+        patternUnits,
+        patternContentUnits,
+        width: size.width,
+        height: size.height,
+        children: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            x: "0",
+            y: "0",
+            width: size.width,
+            height: size.height,
+            fill: paint,
+            mask: `url(#${maskId})`
+          }
+        )
+      }
+    )
+  ] });
+}
+function AreaGradientFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: `${id}-area-gradient-fade-${dataKey}`, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "white", stopOpacity: "var(--chart-fill)" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "white", stopOpacity: 0 })
+    ] }),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "gradient",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            width: "100%",
+            height: "100%",
+            fill: `url(#${id}-area-gradient-fade-${dataKey})`
+          }
+        )
+      }
+    )
+  ] });
+}
+function AreaGradientReverseFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: `${id}-area-reverse-fade-${dataKey}`, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "white", stopOpacity: 0 }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "white", stopOpacity: "var(--chart-fill)" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "gradient-reverse",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: `url(#${id}-area-reverse-fade-${dataKey})` })
+      }
+    )
+  ] });
+}
+function AreaSolidFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsx(
+    MaskedFill,
+    {
+      name: "solid",
+      id,
+      dataKey,
+      texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: "white", fillOpacity: "var(--chart-fill)" })
+    }
+  );
+}
+function AreaDottedFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "pattern",
+      {
+        id: `${id}-area-dotted-texture-${dataKey}`,
+        x: "0",
+        y: "0",
+        width: "6",
+        height: "6",
+        patternUnits: "userSpaceOnUse",
+        children: /* @__PURE__ */ jsx("circle", { cx: "4", cy: "4", r: "0.5", fill: "white" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "dotted",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            width: "100%",
+            height: "100%",
+            fill: `url(#${id}-area-dotted-texture-${dataKey})`,
+            fillOpacity: "var(--chart-texture)"
+          }
+        )
+      }
+    )
+  ] });
+}
+function AreaLinesFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "pattern",
+      {
+        id: `${id}-area-lines-texture-${dataKey}`,
+        patternUnits: "userSpaceOnUse",
+        width: "5",
+        height: "5",
+        patternTransform: "rotate(45)",
+        children: /* @__PURE__ */ jsx("line", { x1: "0", y1: "0", x2: "0", y2: "5", stroke: "white", strokeWidth: "1" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "lines",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            width: "100%",
+            height: "100%",
+            fill: `url(#${id}-area-lines-texture-${dataKey})`,
+            fillOpacity: "var(--chart-texture)"
+          }
+        )
+      }
+    )
+  ] });
+}
+function AreaHatchedFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: `${id}-area-hatched-stripe-${dataKey}`, x1: "0", y1: "0", x2: "1", y2: "0", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "50%", stopColor: "white", stopOpacity: 0.2 }),
+      /* @__PURE__ */ jsx("stop", { offset: "50%", stopColor: "white", stopOpacity: 1 })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "pattern",
+      {
+        id: `${id}-area-hatched-texture-${dataKey}`,
+        x: "0",
+        y: "0",
+        width: "20",
+        height: "10",
+        patternUnits: "userSpaceOnUse",
+        overflow: "visible",
+        patternTransform: "rotate(20)",
+        children: /* @__PURE__ */ jsx("rect", { width: "20", height: "10", fill: `url(#${id}-area-hatched-stripe-${dataKey})` })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "hatched",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            width: "100%",
+            height: "100%",
+            fill: `url(#${id}-area-hatched-texture-${dataKey})`,
+            fillOpacity: "var(--chart-texture)"
+          }
+        )
+      }
+    )
+  ] });
+}
+function UnselectedFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "pattern",
+      {
+        id: `${id}-unselected-texture-${dataKey}`,
+        patternUnits: "userSpaceOnUse",
+        width: "5",
+        height: "5",
+        patternTransform: "rotate(45)",
+        children: /* @__PURE__ */ jsx("line", { x1: "0", y1: "0", x2: "0", y2: "5", stroke: "white", strokeWidth: "1" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "unselected",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            width: "100%",
+            height: "100%",
+            fill: `url(#${id}-unselected-texture-${dataKey})`,
+            fillOpacity: "var(--chart-texture)"
+          }
+        )
+      }
+    )
+  ] });
+}
+function BarHatchedFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      "pattern",
+      {
+        id: `${id}-bar-hatched-texture-${dataKey}`,
+        x: "0",
+        y: "0",
+        width: "5",
+        height: "5",
+        patternUnits: "userSpaceOnUse",
+        patternTransform: "rotate(-45)",
+        children: [
+          /* @__PURE__ */ jsx("rect", { width: "5", height: "5", fill: "white", fillOpacity: 0.3 }),
+          /* @__PURE__ */ jsx("rect", { width: "1.5", height: "5", fill: "white", fillOpacity: 1 })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "hatched",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: `url(#${id}-bar-hatched-texture-${dataKey})` })
+      }
+    )
+  ] });
+}
+function BarBufferFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      "pattern",
+      {
+        id: `${id}-bar-buffer-texture-${dataKey}`,
+        x: "0",
+        y: "0",
+        width: "5",
+        height: "5",
+        patternUnits: "userSpaceOnUse",
+        patternTransform: "rotate(-45)",
+        children: [
+          /* @__PURE__ */ jsx("rect", { width: "5", height: "5", fill: "black", fillOpacity: 0 }),
+          /* @__PURE__ */ jsx("rect", { width: "1", height: "5", fill: "white", fillOpacity: 1 })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "buffer",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: `url(#${id}-bar-buffer-texture-${dataKey})` })
+      }
+    )
+  ] });
+}
+function BarDuotoneFill({
+  id,
+  dataKey,
+  config,
+  reverse = false
+}) {
+  const name = reverse ? "duotone-reverse" : "duotone";
+  const stops = colorStops(config[dataKey]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      "linearGradient",
+      {
+        id: `${id}-${name}-split-${dataKey}`,
+        gradientUnits: "objectBoundingBox",
+        x1: "0",
+        y1: "0",
+        x2: "1",
+        y2: "0",
+        children: [
+          /* @__PURE__ */ jsx("stop", { offset: "50%", stopColor: "white", stopOpacity: reverse ? 1 : 0.4 }),
+          /* @__PURE__ */ jsx("stop", { offset: "50%", stopColor: "white", stopOpacity: reverse ? 0.4 : 1 })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "linearGradient",
+      {
+        id: `${id}-${name}-colors-${dataKey}`,
+        gradientUnits: "objectBoundingBox",
+        x1: "0",
+        y1: "0",
+        x2: "0",
+        y2: "1",
+        children: /* @__PURE__ */ jsx(ColorStops, { dataKey, stops })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name,
+        id,
+        dataKey,
+        patternUnits: "objectBoundingBox",
+        patternContentUnits: "objectBoundingBox",
+        maskContentUnits: "objectBoundingBox",
+        size: { width: 1, height: 1 },
+        fill: `url(#${id}-${name}-colors-${dataKey})`,
+        texture: /* @__PURE__ */ jsx(
+          "rect",
+          {
+            x: "0",
+            y: "0",
+            width: "1",
+            height: "1",
+            fill: `url(#${id}-${name}-split-${dataKey})`
+          }
+        )
+      }
+    )
+  ] });
+}
+function BarGradientFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: `${id}-bar-gradient-fade-${dataKey}`, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "20%", stopColor: "white", stopOpacity: 1 }),
+      /* @__PURE__ */ jsx("stop", { offset: "90%", stopColor: "white", stopOpacity: 0 })
+    ] }),
+    /* @__PURE__ */ jsx(
+      MaskedFill,
+      {
+        name: "gradient",
+        id,
+        dataKey,
+        texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: `url(#${id}-bar-gradient-fade-${dataKey})` })
+      }
+    )
+  ] });
+}
+function BarStrippedFill({ id, dataKey }) {
+  return /* @__PURE__ */ jsx(
+    MaskedFill,
+    {
+      name: "stripped",
+      id,
+      dataKey,
+      texture: /* @__PURE__ */ jsx("rect", { width: "100%", height: "100%", fill: "white", fillOpacity: "var(--chart-fill)" })
+    }
+  );
+}
+function GlowFilter({
+  id,
+  dataKey,
+  spread = 8,
+  intensity = 0.5
+}) {
+  return /* @__PURE__ */ jsxs("filter", { id: `${id}-glow-${dataKey}`, x: "-100%", y: "-100%", width: "300%", height: "300%", children: [
+    /* @__PURE__ */ jsx("feGaussianBlur", { in: "SourceGraphic", stdDeviation: spread, result: "blur" }),
+    /* @__PURE__ */ jsx(
+      "feColorMatrix",
+      {
+        in: "blur",
+        type: "matrix",
+        values: `1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 ${intensity} 0`,
+        result: "glow"
+      }
+    ),
+    /* @__PURE__ */ jsxs("feMerge", { children: [
+      /* @__PURE__ */ jsx("feMergeNode", { in: "glow" }),
+      /* @__PURE__ */ jsx("feMergeNode", { in: "SourceGraphic" })
+    ] })
+  ] });
+}
+function AnimatedDashedStroke({ dash = 3 }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "animate",
+      {
+        attributeName: "stroke-dasharray",
+        values: `${dash} ${dash}; 0 ${dash}; ${dash} ${dash}`,
+        dur: "1s",
+        repeatCount: "indefinite",
+        keyTimes: "0;0.5;1"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "animate",
+      {
+        attributeName: "stroke-dashoffset",
+        values: `0; -${dash * 2}`,
+        dur: "1s",
+        repeatCount: "indefinite",
+        keyTimes: "0;1"
+      }
+    )
+  ] });
+}
+export {
+  AnimatedDashedStroke,
+  AreaDottedFill,
+  AreaGradientFill,
+  AreaGradientReverseFill,
+  AreaHatchedFill,
+  AreaLinesFill,
+  AreaSolidFill,
+  BarBufferFill,
+  BarDuotoneFill,
+  BarGradientFill,
+  BarHatchedFill,
+  BarStrippedFill,
+  ColorStops,
+  GlowFilter,
+  REVEAL_DURATION,
+  REVEAL_EASE,
+  RevealMask,
+  SeriesGradient,
+  UnselectedFill
+};
+//# sourceMappingURL=paint.js.map