@epoch32/visage 0.0.0-stage → 1.0.0

package/dist/src/charts/index.js

@@ -0,0 +1,2717 @@
+// src/signals/types.ts
+var SubscriberState;
+((SubscriberState) => {
+  SubscriberState[SubscriberState["CLEAN"] = 0] = "CLEAN";
+  SubscriberState[SubscriberState["CHECK_DIRTY"] = 1] = "CHECK_DIRTY";
+  SubscriberState[SubscriberState["DIRTY"] = 2] = "DIRTY";
+  SubscriberState[SubscriberState["DISPOSED"] = 3] = "DISPOSED";
+})(SubscriberState ||= {});
+var SIGNAL_BRAND = Symbol("visage.signal");
+var COMPUTED_BRAND = Symbol("visage.computed");
+function isSignal(value) {
+  return typeof value === "function" && ((SIGNAL_BRAND in value) || (COMPUTED_BRAND in value));
+}
+
+// src/signals/system.ts
+var currentSubscriber = null;
+var currentScope = null;
+var batchDepth = 0;
+var pendingEffects = new Set;
+var warnedCyclicSubscribers = new WeakSet;
+var isFlushing = false;
+function setCurrentSubscriber(sub) {
+  currentSubscriber = sub;
+}
+function setCurrentScope(scope) {
+  currentScope = scope;
+}
+function getCurrentScope() {
+  return currentScope;
+}
+function addPendingEffect(eff) {
+  pendingEffects.add(eff);
+}
+function removePendingEffect(eff) {
+  pendingEffects.delete(eff);
+}
+var MAX_FLUSH_COUNT = 100;
+function flushEffects() {
+  if (isFlushing || batchDepth > 0)
+    return;
+  isFlushing = true;
+  let iterations = 0;
+  try {
+    while (pendingEffects.size > 0) {
+      if (++iterations > MAX_FLUSH_COUNT) {
+        pendingEffects.clear();
+        throw new Error(`[Visage Reactivity] Maximum update depth exceeded (${MAX_FLUSH_COUNT} cycles). ` + `An effect continuously triggered state mutations (infinite loop detected). ` + `Ensure effects that modify signals do not unconditionally depend on them, or use untrack() to read state.`);
+      }
+      const effectsToRun = Array.from(pendingEffects);
+      pendingEffects.clear();
+      for (const eff of effectsToRun) {
+        if (eff.state === 2 /* DIRTY */ || eff.state === 1 /* CHECK_DIRTY */) {
+          eff.run();
+        }
+      }
+    }
+  } finally {
+    isFlushing = false;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushEffects();
+    }
+  }
+}
+function untrack(fn) {
+  const prev = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
+
+// src/signals/computed.ts
+class Computed {
+  [COMPUTED_BRAND] = true;
+  _fn;
+  _value;
+  _subscribers = new Set;
+  sources = new Set;
+  sourceVersions = new Map;
+  state = 2 /* DIRTY */;
+  scope;
+  version = 0;
+  constructor(fn) {
+    this._fn = fn;
+    this.scope = currentScope;
+    if (currentScope) {
+      currentScope.addSubscriber(this);
+    }
+  }
+  get() {
+    if (this.state === 3 /* DISPOSED */) {
+      return this._fn();
+    }
+    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
+      this._subscribers.add(currentSubscriber);
+      currentSubscriber.sources.add(this);
+      currentSubscriber.sourceVersions.set(this, this.version);
+    }
+    if (this.state === 2 /* DIRTY */ || this.state === 1 /* CHECK_DIRTY */) {
+      this.updateIfNecessary();
+    }
+    return this._value;
+  }
+  get value() {
+    return this.get();
+  }
+  removeSubscriber(sub) {
+    this._subscribers.delete(sub);
+  }
+  markDirty(targetState = 1 /* CHECK_DIRTY */) {
+    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
+      return;
+    }
+    this.state = targetState;
+    for (const sub of this._subscribers) {
+      sub.markDirty(1 /* CHECK_DIRTY */);
+    }
+  }
+  updateIfNecessary() {
+    if (this.state === 2 /* DIRTY */) {
+      const prev = this._value;
+      this.recompute();
+      return !Object.is(prev, this._value);
+    }
+    if (this.state === 1 /* CHECK_DIRTY */) {
+      let anyChanged = false;
+      for (const source of this.sources) {
+        if (source instanceof Computed) {
+          source.updateIfNecessary();
+        }
+        const lastVersion = this.sourceVersions.get(source);
+        if (lastVersion !== undefined && lastVersion !== source.version) {
+          anyChanged = true;
+        }
+      }
+      if (anyChanged) {
+        const prev = this._value;
+        this.recompute();
+        return !Object.is(prev, this._value);
+      }
+      this.state = 0 /* CLEAN */;
+      return false;
+    }
+    return false;
+  }
+  recompute() {
+    this.cleanupSources();
+    const prevSubscriber = currentSubscriber;
+    setCurrentSubscriber(this);
+    const prevScope = currentScope;
+    setCurrentScope(this.scope);
+    try {
+      const next = this._fn();
+      if (!Object.is(this._value, next)) {
+        this._value = next;
+        this.version++;
+      }
+      this.state = 0 /* CLEAN */;
+    } finally {
+      setCurrentSubscriber(prevSubscriber);
+      setCurrentScope(prevScope);
+    }
+  }
+  cleanupSources() {
+    for (const source of this.sources) {
+      source.removeSubscriber(this);
+    }
+    this.sources.clear();
+    this.sourceVersions.clear();
+  }
+  dispose() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    this.state = 3 /* DISPOSED */;
+    this.cleanupSources();
+    this._subscribers.clear();
+  }
+}
+function computed(fn, options) {
+  const isInternal = options?.internal ?? false;
+  const customName = options?.name;
+  const c = new Computed(fn);
+  const accessor = () => c.get();
+  Object.defineProperties(accessor, {
+    [COMPUTED_BRAND]: { value: true },
+    get: { value: () => c.get() },
+    value: { get: () => c.get() }
+  });
+  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
+    const devtools = window.__VISAGE_DEVTOOLS__;
+    const sigId = devtools.registerSignal({
+      name: customName,
+      type: "computed",
+      getValue: () => c.get(),
+      version: () => c.version,
+      subscribersCount: () => c._subscribers?.size ?? 0,
+      dependencies: () => Array.from(c.sources ?? []).map((src) => src._devId).filter(Boolean),
+      dependents: () => Array.from(c._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
+    });
+    c._devId = sigId;
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        devtools.unregisterSignal(sigId);
+      });
+    }
+  }
+  return accessor;
+}
+var createMemo = computed;
+// src/style/cx.ts
+function hasReactiveClass(val) {
+  if (typeof val === "function")
+    return true;
+  if (Array.isArray(val)) {
+    for (let i = 0;i < val.length; i++) {
+      if (hasReactiveClass(val[i]))
+        return true;
+    }
+    return false;
+  }
+  if (typeof val === "object" && val !== null) {
+    for (const k in val) {
+      if (typeof val[k] === "function")
+        return true;
+    }
+  }
+  return false;
+}
+function normalizeClass(val) {
+  if (!val)
+    return "";
+  if (typeof val === "function")
+    return normalizeClass(val());
+  if (typeof val === "string")
+    return val.trim();
+  if (typeof val === "number")
+    return String(val);
+  if (Array.isArray(val)) {
+    let res = "";
+    for (let i = 0;i < val.length; i++) {
+      const item = typeof val[i] === "function" ? val[i]() : val[i];
+      const itemStr = normalizeClass(item);
+      if (itemStr) {
+        res = res ? `${res} ${itemStr}` : itemStr;
+      }
+    }
+    return res;
+  }
+  if (typeof val === "object") {
+    let res = "";
+    for (const key in val) {
+      const condition = typeof val[key] === "function" ? val[key]() : val[key];
+      if (condition) {
+        res = res ? `${res} ${key}` : key;
+      }
+    }
+    return res;
+  }
+  return "";
+}
+function cx(...args) {
+  return normalizeClass(args);
+}
+
+// src/style/scale.ts
+var UNITLESS_PROPERTIES = new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageSlice",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexShrink",
+  "flexOrder",
+  "fontWeight",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "strokeOpacity"
+]);
+var DIMENSION_KEYWORDS = {
+  screen: "100dvh",
+  "screen-h": "100dvh",
+  "screen-w": "100dvw",
+  full: "100%",
+  half: "50%",
+  third: "33.333333%",
+  "two-thirds": "66.666667%",
+  quarter: "25%",
+  "three-quarters": "75%",
+  auto: "auto",
+  min: "min-content",
+  max: "max-content",
+  fit: "fit-content"
+};
+function space(val) {
+  if (val === undefined || val === null || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0)
+      return "0px";
+    return `${val * 4}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+function resolveDimension(val) {
+  if (val === undefined || val === null || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0)
+      return "0px";
+    if (val > 48)
+      return `${val}px`;
+    return `${val * 4}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+function px(val) {
+  return `${val}px`;
+}
+function rem(val) {
+  return `${val}rem`;
+}
+function em(val) {
+  return `${val}em`;
+}
+function fluid(minPx, maxPx, options) {
+  const minVw = options?.minVw ?? 375;
+  const maxVw = options?.maxVw ?? 1280;
+  const slope = (maxPx - minPx) / (maxVw - minVw);
+  const yIntercept = -minVw * slope + minPx;
+  const slopeVw = slope * 100;
+  const preferred = `${yIntercept.toFixed(2)}px + ${slopeVw.toFixed(2)}vw`;
+  const min = Math.min(minPx, maxPx);
+  const max = Math.max(minPx, maxPx);
+  return `clamp(${min}px, ${preferred}, ${max}px)`;
+}
+var SHADOW_PRESETS = {
+  none: "none",
+  sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+  md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+  lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+  xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)",
+  soft: "0 8px 30px rgba(0, 0, 0, 0.06)",
+  glow: "0 0 24px rgba(168, 85, 247, 0.35)",
+  inner: "inset 0 2px 4px 0 rgba(0, 0, 0, 0.06)"
+};
+function shadow(variant) {
+  if (variant in SHADOW_PRESETS) {
+    return SHADOW_PRESETS[variant];
+  }
+  return variant;
+}
+var RADIUS_PRESETS = {
+  none: "0px",
+  sm: "4px",
+  md: "8px",
+  lg: "12px",
+  xl: "16px",
+  "2xl": "20px",
+  "3xl": "24px",
+  full: "9999px"
+};
+function radius(variant) {
+  if (typeof variant === "number") {
+    return `${variant}px`;
+  }
+  if (variant in RADIUS_PRESETS) {
+    return RADIUS_PRESETS[variant];
+  }
+  return String(variant);
+}
+function glass(options = {}) {
+  const blurVal = typeof options.blur === "number" ? `${options.blur}px` : options.blur ?? "20px";
+  const tintVal = options.tint ?? "rgba(255, 255, 255, 0.65)";
+  const borderVal = options.border ?? "1px solid rgba(255, 255, 255, 0.75)";
+  return {
+    backdropFilter: `blur(${blurVal})`,
+    WebkitBackdropFilter: `blur(${blurVal})`,
+    backgroundColor: tintVal,
+    border: borderVal
+  };
+}
+function formatStyleProp(prop, val) {
+  if (val === null || val === undefined || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0 || UNITLESS_PROPERTIES.has(prop)) {
+      return String(val);
+    }
+    return `${val}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    const lowerProp = prop.toLowerCase();
+    if (str === "screen") {
+      if (lowerProp.includes("width"))
+        return "100dvw";
+      return "100dvh";
+    }
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+
+// src/dom/render.ts
+function isReactive(value) {
+  return isSignal(value) || typeof value === "function";
+}
+function resolveValue(val) {
+  if (typeof val === "function") {
+    return val();
+  }
+  return val;
+}
+function render(fn, container) {
+  return createRoot((dispose) => {
+    container.textContent = "";
+    const node = insertChild(container, fn());
+    onCleanup(() => {
+      if (node && node instanceof Node && node.parentNode === container) {
+        container.removeChild(node);
+      }
+    });
+    return dispose;
+  });
+}
+function setAttribute(el, key, value) {
+  if (key.startsWith("on") && typeof value === "function") {
+    const eventName = key.startsWith("onCapture") ? key.slice(9).toLowerCase() : key.slice(2).toLowerCase();
+    const useCapture = key.startsWith("onCapture");
+    el.addEventListener(eventName, value, useCapture);
+    onCleanup(() => {
+      el.removeEventListener(eventName, value, useCapture);
+    });
+    return;
+  }
+  if (key === "ref" && typeof value === "function") {
+    value(el);
+    return;
+  }
+  if (key === "class" || key === "className") {
+    if (hasReactiveClass(value)) {
+      effect(() => {
+        const cls = normalizeClass(value);
+        if (cls)
+          el.setAttribute("class", cls);
+        else
+          el.removeAttribute("class");
+      });
+    } else {
+      const cls = normalizeClass(value);
+      if (cls)
+        el.setAttribute("class", cls);
+      else
+        el.removeAttribute("class");
+    }
+    return;
+  }
+  if (isReactive(value)) {
+    effect(() => {
+      const resolved = resolveValue(value);
+      applyProp(el, key, resolved);
+    });
+  } else {
+    applyProp(el, key, value);
+  }
+}
+function setStyleProperty(el, prop, val) {
+  const formatted = formatStyleProp(prop, val);
+  if (prop.startsWith("--") || prop.includes("-")) {
+    if (formatted === "") {
+      el.style.removeProperty(prop);
+    } else {
+      el.style.setProperty(prop, formatted);
+    }
+  } else {
+    el.style[prop] = formatted;
+  }
+}
+function applyProp(el, key, value) {
+  if (value === null || value === undefined || value === false && !key.startsWith("aria-") && !key.startsWith("data-")) {
+    if (key === "className" || key === "class") {
+      el.removeAttribute("class");
+    } else if (key === "style" && typeof value === "string") {
+      el.removeAttribute("style");
+    } else if (key in el && !(el instanceof SVGElement)) {
+      try {
+        el[key] = typeof el[key] === "boolean" ? false : "";
+      } catch {
+        el.removeAttribute(key);
+      }
+    } else {
+      el.removeAttribute(key);
+    }
+    return;
+  }
+  if (key === "className" || key === "class") {
+    const cls = normalizeClass(value);
+    if (cls) {
+      el.setAttribute("class", cls);
+    } else {
+      el.removeAttribute("class");
+    }
+  } else if (key === "style") {
+    if (typeof value === "string") {
+      el.setAttribute("style", value);
+    } else if (typeof value === "object" && value !== null) {
+      for (const styleKey in value) {
+        const styleVal = value[styleKey];
+        if (isReactive(styleVal)) {
+          effect(() => {
+            setStyleProperty(el, styleKey, resolveValue(styleVal));
+          });
+        } else {
+          setStyleProperty(el, styleKey, styleVal);
+        }
+      }
+    }
+  } else if (key === "dangerouslySetInnerHTML" && value && typeof value.__html === "string") {
+    el.innerHTML = value.__html;
+  } else if (key in el && !(el instanceof SVGElement) && key !== "list" && key !== "form") {
+    try {
+      el[key] = value;
+    } catch {
+      el.setAttribute(key, String(value));
+    }
+  } else {
+    if (key.startsWith("aria-") || key.startsWith("data-")) {
+      el.setAttribute(key, String(value));
+    } else if (value === true) {
+      el.setAttribute(key, "");
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+}
+function insertChild(parent, child, before = null) {
+  if (child === null || child === undefined || child === false || child === true) {
+    return null;
+  }
+  if (child instanceof Node) {
+    parent.insertBefore(child, before);
+    return child;
+  }
+  if (Array.isArray(child)) {
+    const fragment = document.createDocumentFragment();
+    for (const item of child) {
+      insertChild(fragment, item);
+    }
+    parent.insertBefore(fragment, before);
+    return fragment;
+  }
+  if (isReactive(child)) {
+    const marker = document.createTextNode("");
+    parent.insertBefore(marker, before);
+    let childScope = null;
+    let currentNodes = [];
+    effect(() => {
+      const resolved = resolveValue(child);
+      if ((typeof resolved === "string" || typeof resolved === "number") && currentNodes.length === 1 && currentNodes[0].nodeType === Node.TEXT_NODE) {
+        currentNodes[0].data = String(resolved);
+        return;
+      }
+      if (childScope) {
+        childScope.dispose();
+      }
+      childScope = new Scope(getActiveScope());
+      runInScope(childScope, () => {
+        for (const node of currentNodes) {
+          if (node.parentNode) {
+            node.parentNode.removeChild(node);
+          }
+        }
+        currentNodes = [];
+        if (resolved === null || resolved === undefined || resolved === false) {
+          return;
+        }
+        const frag = document.createDocumentFragment();
+        if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") {
+          frag.appendChild(document.createTextNode(String(resolved)));
+        } else {
+          insertChild(frag, resolved);
+        }
+        currentNodes = Array.from(frag.childNodes);
+        if (marker.parentNode) {
+          marker.parentNode.insertBefore(frag, marker);
+        }
+      });
+    });
+    onCleanup(() => {
+      if (childScope) {
+        childScope.dispose();
+      }
+      for (const node of currentNodes) {
+        if (node.parentNode) {
+          node.parentNode.removeChild(node);
+        }
+      }
+      if (marker.parentNode) {
+        marker.parentNode.removeChild(marker);
+      }
+    });
+    return marker;
+  }
+  const textNode = document.createTextNode(String(child));
+  parent.insertBefore(textNode, before);
+  return textNode;
+}
+
+// src/signals/scope.ts
+class Scope {
+  subscribers = new Set;
+  cleanups = [];
+  parent = null;
+  isDisposed = false;
+  context;
+  constructor(parent = currentScope) {
+    this.parent = parent;
+    if (parent && !parent.isDisposed) {
+      parent.cleanups.push(() => this.dispose());
+      if (parent.context) {
+        this.context = new Map(parent.context);
+      }
+    }
+  }
+  addSubscriber(sub) {
+    if (this.isDisposed)
+      return;
+    this.subscribers.add(sub);
+  }
+  addCleanup(fn) {
+    if (this.isDisposed) {
+      fn();
+      return;
+    }
+    this.cleanups.push(fn);
+  }
+  dispose() {
+    if (this.isDisposed)
+      return;
+    this.isDisposed = true;
+    for (const sub of this.subscribers) {
+      sub.dispose();
+    }
+    this.subscribers.clear();
+    for (let i = this.cleanups.length - 1;i >= 0; i--) {
+      try {
+        this.cleanups[i]();
+      } catch (err) {
+        console.error("Error during cleanup:", err);
+      }
+    }
+    this.cleanups = [];
+  }
+}
+function onCleanup(fn) {
+  if (currentSubscriber && "addCleanup" in currentSubscriber) {
+    currentSubscriber.addCleanup(fn);
+  } else if (currentScope) {
+    currentScope.addCleanup(fn);
+  }
+}
+function createRoot(fn) {
+  const prevScope = currentScope;
+  const scope = new Scope(null);
+  setCurrentScope(scope);
+  try {
+    return fn(() => scope.dispose());
+  } finally {
+    setCurrentScope(prevScope);
+  }
+}
+function runInScope(scope, fn) {
+  const prevScope = currentScope;
+  setCurrentScope(scope);
+  try {
+    return fn();
+  } finally {
+    setCurrentScope(prevScope);
+  }
+}
+function getActiveScope() {
+  return getCurrentScope();
+}
+
+// src/signals/context.ts
+function createContext(defaultValue) {
+  const id = Symbol("visage.context");
+  const context = {
+    id,
+    defaultValue,
+    Provider: (props) => {
+      const parentScope = getActiveScope();
+      const scope = new Scope(parentScope);
+      if (!scope.context) {
+        scope.context = new Map(parentScope?.context);
+      }
+      scope.context.set(id, props.value);
+      return runInScope(scope, () => {
+        const content = typeof props.children === "function" ? untrack(() => props.children()) : props.children;
+        if (typeof document !== "undefined") {
+          const frag = document.createDocumentFragment();
+          insertChild(frag, content);
+          return frag;
+        }
+        return content;
+      });
+    }
+  };
+  return context;
+}
+function useContext(context) {
+  let scope = getActiveScope();
+  while (scope) {
+    if (scope.context?.has(context.id)) {
+      return scope.context.get(context.id);
+    }
+    scope = scope.parent;
+  }
+  return context.defaultValue;
+}
+// src/signals/effect.ts
+class Effect {
+  _fn;
+  sources = new Set;
+  sourceVersions = new Map;
+  cleanups = [];
+  state = 2 /* DIRTY */;
+  scope;
+  constructor(fn) {
+    this._fn = fn;
+    this.scope = currentScope;
+    if (currentScope) {
+      currentScope.addSubscriber(this);
+    }
+    this.run();
+  }
+  addCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+  runCleanups() {
+    for (let i = this.cleanups.length - 1;i >= 0; i--) {
+      try {
+        this.cleanups[i]();
+      } catch (e) {
+        console.error("Error in effect cleanup:", e);
+      }
+    }
+    this.cleanups = [];
+  }
+  markDirty(targetState = 2 /* DIRTY */) {
+    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
+      return;
+    }
+    this.state = targetState;
+    addPendingEffect(this);
+    if (batchDepth === 0) {
+      flushEffects();
+    }
+  }
+  run() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    if (this.state === 1 /* CHECK_DIRTY */) {
+      let isDirty = false;
+      for (const source of this.sources) {
+        if (source instanceof Computed) {
+          source.updateIfNecessary();
+        }
+        const lastVersion = this.sourceVersions.get(source);
+        if (lastVersion !== undefined && lastVersion !== source.version) {
+          isDirty = true;
+        }
+      }
+      if (!isDirty) {
+        this.state = 0 /* CLEAN */;
+        return;
+      }
+    }
+    this.runCleanups();
+    this.cleanupSources();
+    const prevSubscriber = currentSubscriber;
+    setCurrentSubscriber(this);
+    const prevScope = currentScope;
+    setCurrentScope(this.scope);
+    try {
+      this.state = 0 /* CLEAN */;
+      const res = this._fn();
+      if (typeof res === "function") {
+        this.cleanups.push(res);
+      }
+    } finally {
+      setCurrentSubscriber(prevSubscriber);
+      setCurrentScope(prevScope);
+    }
+  }
+  cleanupSources() {
+    for (const source of this.sources) {
+      source.removeSubscriber(this);
+    }
+    this.sources.clear();
+    this.sourceVersions.clear();
+  }
+  dispose() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    this.state = 3 /* DISPOSED */;
+    this.runCleanups();
+    this.cleanupSources();
+    removePendingEffect(this);
+  }
+}
+function effect(fn) {
+  const eff = new Effect(fn);
+  return () => eff.dispose();
+}
+var createEffect = effect;
+// src/signals/signal.ts
+class Signal {
+  [SIGNAL_BRAND] = true;
+  _value;
+  _subscribers = new Set;
+  _equals;
+  version = 0;
+  constructor(initialValue, equals) {
+    this._value = initialValue;
+    this._equals = equals ?? Object.is;
+  }
+  get() {
+    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
+      this._subscribers.add(currentSubscriber);
+      currentSubscriber.sources.add(this);
+      currentSubscriber.sourceVersions.set(this, this.version);
+    }
+    return this._value;
+  }
+  set(newValue) {
+    if (this._equals(this._value, newValue)) {
+      return;
+    }
+    if (currentSubscriber !== null && this._subscribers.has(currentSubscriber)) {
+      if (!warnedCyclicSubscribers.has(currentSubscriber)) {
+        warnedCyclicSubscribers.add(currentSubscriber);
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+          console.warn(`[Visage Reactivity] Cyclic update detected: An active subscriber modified a signal that it depends on. ` + `To read a signal inside an effect/computed without creating a circular dependency, wrap the read in untrack():
+` + `  untrack(() => signal())`);
+        }
+      }
+    }
+    this._value = newValue;
+    this.version++;
+    batch(() => {
+      this.notify();
+    });
+  }
+  update(fn) {
+    this.set(fn(this._value));
+  }
+  get value() {
+    return this.get();
+  }
+  set value(val) {
+    this.set(val);
+  }
+  removeSubscriber(sub) {
+    this._subscribers.delete(sub);
+  }
+  notify() {
+    if (this._subscribers.size === 0)
+      return;
+    const subs = Array.from(this._subscribers);
+    for (const sub of subs) {
+      sub.markDirty(2 /* DIRTY */);
+    }
+  }
+}
+function signal(initialValue, optionsOrEquals) {
+  const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
+  const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
+  const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
+  const s = new Signal(initialValue, equals);
+  const accessor = (...args) => {
+    if (args.length === 0) {
+      return s.get();
+    }
+    s.set(args[0]);
+    return args[0];
+  };
+  Object.defineProperties(accessor, {
+    [SIGNAL_BRAND]: { value: true },
+    get: { value: () => s.get() },
+    set: { value: (v) => s.set(v) },
+    update: { value: (fn) => s.update(fn) },
+    value: {
+      get: () => s.get(),
+      set: (v) => s.set(v)
+    }
+  });
+  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
+    const devtools = window.__VISAGE_DEVTOOLS__;
+    const sigId = devtools.registerSignal({
+      name: customName,
+      type: "signal",
+      getValue: () => s.get(),
+      version: () => s.version,
+      subscribersCount: () => s._subscribers?.size ?? 0,
+      dependents: () => Array.from(s._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
+    });
+    s._devId = sigId;
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        devtools.unregisterSignal(sigId);
+      });
+    }
+  }
+  return accessor;
+}
+function createSignal(initialValue, optionsOrEquals) {
+  const s = signal(initialValue, optionsOrEquals);
+  const setter = (value) => {
+    if (typeof value === "function") {
+      s.update(value);
+    } else {
+      s.set(value);
+    }
+  };
+  return [s, setter];
+}
+// src/signals/store.ts
+var STORE_RAW = Symbol("visage.store.raw");
+var STORE_SIGNALS = Symbol("visage.store.signals");
+var STORE_PROXY = Symbol("visage.store.proxy");
+function isObject(val) {
+  return typeof val === "object" && val !== null && (typeof Node === "undefined" || !(val instanceof Node)) && !isSignal(val);
+}
+function getOrCreatePropertySignal(target, prop) {
+  let signalsMap = target[STORE_SIGNALS];
+  if (!signalsMap) {
+    signalsMap = new Map;
+    Object.defineProperty(target, STORE_SIGNALS, {
+      value: signalsMap,
+      enumerable: false,
+      writable: true
+    });
+  }
+  let sig = signalsMap.get(prop);
+  if (!sig) {
+    sig = new Signal(target[prop]);
+    signalsMap.set(prop, sig);
+  }
+  return sig;
+}
+function createStoreProxy(target) {
+  if (!isObject(target))
+    return target;
+  if (target[STORE_PROXY])
+    return target[STORE_PROXY];
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === STORE_RAW)
+        return target;
+      if (prop === STORE_PROXY)
+        return proxy;
+      if (typeof prop === "string" || typeof prop === "symbol") {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.get();
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (isObject(value)) {
+        return createStoreProxy(value);
+      }
+      return value;
+    },
+    set(target, prop, value, receiver) {
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (Object.is(prevValue, value)) {
+        return true;
+      }
+      const success = Reflect.set(target, prop, value, receiver);
+      if (success) {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.set(value);
+        if (Array.isArray(target) && prop !== "length") {
+          const lenSig = getOrCreatePropertySignal(target, "length");
+          lenSig.set(target.length);
+        }
+      }
+      return success;
+    },
+    deleteProperty(target, prop) {
+      const hadProp = Reflect.has(target, prop);
+      const success = Reflect.deleteProperty(target, prop);
+      if (hadProp && success) {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.set(undefined);
+      }
+      return success;
+    }
+  });
+  Object.defineProperty(target, STORE_PROXY, {
+    value: proxy,
+    enumerable: false,
+    writable: true
+  });
+  return proxy;
+}
+function createStore(initialState) {
+  if (!isObject(initialState)) {
+    throw new Error("createStore requires an object or array as initial state");
+  }
+  return createStoreProxy(initialState);
+}
+function mutateStore(store, mutator) {
+  batch(() => {
+    mutator(store);
+  });
+}
+function unwrapStore(store) {
+  if (isObject(store) && store[STORE_RAW]) {
+    return store[STORE_RAW];
+  }
+  return store;
+}
+// src/charts/context.ts
+var ChartContext = createContext(undefined);
+function useChartContext() {
+  const ctx = useContext(ChartContext);
+  if (!ctx) {
+    throw new Error("Visage Chart child component must be rendered within a <Chart> container.");
+  }
+  return ctx;
+}
+
+// src/charts/path.ts
+function pathLine(points, options = {}) {
+  if (points.length === 0)
+    return "";
+  if (points.length === 1) {
+    const p = points[0];
+    return `M ${p.x.toFixed(2)},${p.y.toFixed(2)}`;
+  }
+  const curve = options.curve ?? "linear";
+  if (curve === "smooth" && points.length >= 2) {
+    if (points.length === 2) {
+      const p0 = points[0];
+      const p1 = points[1];
+      return `M ${p0.x.toFixed(2)},${p0.y.toFixed(2)} L ${p1.x.toFixed(2)},${p1.y.toFixed(2)}`;
+    }
+    const n = points.length;
+    const dx = [];
+    const dy = [];
+    const slopes = [];
+    for (let i = 0;i < n - 1; i++) {
+      const pA = points[i];
+      const pB = points[i + 1];
+      const deltaX = pB.x - pA.x;
+      const deltaY = pB.y - pA.y;
+      dx.push(deltaX);
+      dy.push(deltaY);
+      slopes.push(deltaX === 0 ? 0 : deltaY / deltaX);
+    }
+    const m = new Array(n).fill(0);
+    m[0] = slopes[0];
+    m[n - 1] = slopes[n - 2];
+    for (let i = 1;i < n - 1; i++) {
+      const sPrev = slopes[i - 1];
+      const sNext = slopes[i];
+      if (sPrev * sNext <= 0) {
+        m[i] = 0;
+      } else {
+        const dxPrev = dx[i - 1];
+        const dxNext = dx[i];
+        const common = dxPrev + dxNext;
+        m[i] = common === 0 ? 0 : 3 * common / ((common + dxNext) / sPrev + (common + dxPrev) / sNext);
+      }
+    }
+    let d = `M ${points[0].x.toFixed(2)},${points[0].y.toFixed(2)}`;
+    for (let i = 0;i < n - 1; i++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const deltaX = dx[i];
+      const cp1x = p1.x + deltaX / 3;
+      const cp1y = p1.y + m[i] * deltaX / 3;
+      const cp2x = p2.x - deltaX / 3;
+      const cp2y = p2.y - m[i + 1] * deltaX / 3;
+      d += ` C ${cp1x.toFixed(2)},${cp1y.toFixed(2)} ${cp2x.toFixed(2)},${cp2y.toFixed(2)} ${p2.x.toFixed(2)},${p2.y.toFixed(2)}`;
+    }
+    return d;
+  }
+  if (curve === "step") {
+    let d = `M ${points[0].x.toFixed(2)},${points[0].y.toFixed(2)}`;
+    for (let i = 0;i < points.length - 1; i++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const midX = (p1.x + p2.x) / 2;
+      d += ` L ${midX.toFixed(2)},${p1.y.toFixed(2)} L ${midX.toFixed(2)},${p2.y.toFixed(2)} L ${p2.x.toFixed(2)},${p2.y.toFixed(2)}`;
+    }
+    return d;
+  }
+  let d = `M ${points[0].x.toFixed(2)},${points[0].y.toFixed(2)}`;
+  for (let i = 1;i < points.length; i++) {
+    d += ` L ${points[i].x.toFixed(2)},${points[i].y.toFixed(2)}`;
+  }
+  return d;
+}
+function pathArea(points, baselineY, options = {}) {
+  if (points.length === 0)
+    return "";
+  const lineD = pathLine(points, options);
+  if (!lineD)
+    return "";
+  const first = points[0];
+  const last = points[points.length - 1];
+  return `${lineD} L ${last.x.toFixed(2)},${baselineY.toFixed(2)} L ${first.x.toFixed(2)},${baselineY.toFixed(2)} Z`;
+}
+function pathArc(options) {
+  const { cx, cy, innerRadius, outerRadius, startAngle, endAngle } = options;
+  const cosStart = Math.cos(startAngle);
+  const sinStart = Math.sin(startAngle);
+  const cosEnd = Math.cos(endAngle);
+  const sinEnd = Math.sin(endAngle);
+  const x0 = cx + outerRadius * cosStart;
+  const y0 = cy + outerRadius * sinStart;
+  const x1 = cx + outerRadius * cosEnd;
+  const y1 = cy + outerRadius * sinEnd;
+  const largeArcFlag = endAngle - startAngle <= Math.PI ? 0 : 1;
+  if (innerRadius <= 0) {
+    return `M ${cx.toFixed(2)},${cy.toFixed(2)} L ${x0.toFixed(2)},${y0.toFixed(2)} A ${outerRadius.toFixed(2)},${outerRadius.toFixed(2)} 0 ${largeArcFlag} 1 ${x1.toFixed(2)},${y1.toFixed(2)} Z`;
+  }
+  const x2 = cx + innerRadius * cosEnd;
+  const y2 = cy + innerRadius * sinEnd;
+  const x3 = cx + innerRadius * cosStart;
+  const y3 = cy + innerRadius * sinStart;
+  return `M ${x0.toFixed(2)},${y0.toFixed(2)} A ${outerRadius.toFixed(2)},${outerRadius.toFixed(2)} 0 ${largeArcFlag} 1 ${x1.toFixed(2)},${y1.toFixed(2)} L ${x2.toFixed(2)},${y2.toFixed(2)} A ${innerRadius.toFixed(2)},${innerRadius.toFixed(2)} 0 ${largeArcFlag} 0 ${x3.toFixed(2)},${y3.toFixed(2)} Z`;
+}
+
+// src/dom/resource.ts
+var SuspenseContext = createContext(null);
+function createResource(sourceOrFetcher, maybeFetcher) {
+  const isDirect = typeof maybeFetcher !== "function";
+  const fetcher = isDirect ? sourceOrFetcher : maybeFetcher;
+  const source = isDirect ? null : sourceOrFetcher;
+  const data = signal(undefined);
+  const loading = signal(true);
+  const error = signal(null);
+  let currentPromise = null;
+  let requestId = 0;
+  const load = async (arg) => {
+    const currentReq = ++requestId;
+    loading.set(true);
+    error.set(null);
+    const promise = isDirect ? fetcher() : fetcher(arg);
+    currentPromise = promise;
+    const suspense = useContext(SuspenseContext);
+    if (suspense) {
+      suspense.registerPromise(promise);
+    }
+    try {
+      const res = await promise;
+      if (currentReq === requestId) {
+        data.set(res);
+        loading.set(false);
+        currentPromise = null;
+      }
+      return res;
+    } catch (err) {
+      if (currentReq === requestId) {
+        error.set(err);
+        loading.set(false);
+        currentPromise = null;
+      }
+      throw err;
+    }
+  };
+  if (source) {
+    effect(() => {
+      const sourceVal = resolveValue(source);
+      if (sourceVal !== false && sourceVal !== null && sourceVal !== undefined) {
+        load(sourceVal).catch(() => {});
+      }
+    });
+  } else {
+    load().catch(() => {});
+  }
+  const accessor = () => {
+    if (loading() && currentPromise) {
+      const suspense = useContext(SuspenseContext);
+      if (suspense) {
+        suspense.registerPromise(currentPromise);
+      }
+    }
+    return data();
+  };
+  Object.defineProperties(accessor, {
+    loading: { get: () => loading },
+    error: { get: () => error },
+    mutate: { value: (val) => data.set(val) },
+    refetch: { value: () => source ? load(resolveValue(source)) : load() }
+  });
+  return accessor;
+}
+
+// src/dom/lazy.ts
+function lazy(importer) {
+  let loadedComponent = null;
+  let loadingPromise = null;
+  const preload = () => {
+    if (loadedComponent) {
+      return Promise.resolve(loadedComponent);
+    }
+    if (!loadingPromise) {
+      loadingPromise = importer().then((mod) => {
+        const comp = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+        loadedComponent = comp;
+        return comp;
+      }).catch((err) => {
+        loadingPromise = null;
+        throw err;
+      });
+    }
+    return loadingPromise;
+  };
+  const LazyWrapper = (props) => {
+    if (loadedComponent) {
+      return loadedComponent(props);
+    }
+    const promise = preload();
+    const suspense = useContext(SuspenseContext);
+    if (suspense) {
+      suspense.registerPromise(promise);
+    }
+    const res = createResource(() => promise);
+    return () => {
+      const Comp = res();
+      return Comp ? Comp(props) : null;
+    };
+  };
+  LazyWrapper.preload = preload;
+  return LazyWrapper;
+}
+// src/dom/async.ts
+function Suspense(props) {
+  if (typeof document === "undefined") {
+    return typeof props.children === "function" ? props.children() : props.children;
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  const pendingCount = signal(0);
+  let currentScope = null;
+  let currentNodes = [];
+  let isMounted = false;
+  const suspenseValue = {
+    registerPromise(p) {
+      pendingCount.update((c) => c + 1);
+      p.finally(() => {
+        pendingCount.update((c) => Math.max(0, c - 1));
+      });
+    }
+  };
+  const renderContent = (content) => {
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (!parent)
+      return;
+    for (const n of currentNodes) {
+      if (n.parentNode)
+        n.parentNode.removeChild(n);
+    }
+    currentNodes = [];
+    const frag = document.createDocumentFragment();
+    insertChild(frag, content);
+    currentNodes = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  };
+  effect(() => {
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    currentScope = new Scope(getActiveScope());
+    runInScope(currentScope, () => {
+      let threwPromise = null;
+      let rendered = null;
+      try {
+        const SuspenseProvider = SuspenseContext.Provider;
+        rendered = SuspenseProvider({
+          value: suspenseValue,
+          children: props.children
+        });
+      } catch (err) {
+        if (err && typeof err.then === "function") {
+          threwPromise = err;
+          suspenseValue.registerPromise(err);
+        } else {
+          throw err;
+        }
+      }
+      if (pendingCount() > 0 || threwPromise) {
+        renderContent(props.fallback);
+      } else {
+        renderContent(rendered);
+      }
+    });
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope)
+      currentScope.dispose();
+  });
+  return initialFrag;
+}
+function ErrorBoundary(props) {
+  if (typeof document === "undefined") {
+    try {
+      return typeof props.children === "function" ? props.children() : props.children;
+    } catch (err) {
+      return typeof props.fallback === "function" ? props.fallback(err, () => {}) : props.fallback;
+    }
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  const currentError = signal(null);
+  let currentScope = null;
+  let currentNodes = [];
+  let isMounted = false;
+  const reset = () => {
+    currentError.set(null);
+  };
+  const renderNodes = (child) => {
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (!parent)
+      return;
+    for (const n of currentNodes) {
+      if (n.parentNode)
+        n.parentNode.removeChild(n);
+    }
+    currentNodes = [];
+    const frag = document.createDocumentFragment();
+    insertChild(frag, child);
+    currentNodes = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  };
+  effect(() => {
+    const err = currentError();
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    currentScope = new Scope(getActiveScope());
+    runInScope(currentScope, () => {
+      if (err !== null) {
+        const fallbackNode = typeof props.fallback === "function" ? props.fallback(err, reset) : props.fallback;
+        renderNodes(fallbackNode);
+      } else {
+        try {
+          const content = typeof props.children === "function" ? props.children() : props.children;
+          renderNodes(content);
+        } catch (catchedErr) {
+          currentError.set(catchedErr);
+        }
+      }
+    });
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope)
+      currentScope.dispose();
+  });
+  return initialFrag;
+}
+// src/dom/control-flow.ts
+function Show(props) {
+  if (typeof document === "undefined") {
+    const condition = resolveValue(props.when);
+    if (condition) {
+      return typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+    }
+    return props.fallback ?? null;
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  let currentScope = null;
+  let currentContent = [];
+  let isMounted = false;
+  effect(() => {
+    const condition = resolveValue(props.when);
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of currentContent) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    currentContent = [];
+    const frag = document.createDocumentFragment();
+    if (condition) {
+      currentScope = new Scope(getActiveScope());
+      untrack(() => {
+        runInScope(currentScope, () => {
+          const childRes = typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+          insertChild(frag, childRes);
+        });
+      });
+    } else if (props.fallback !== undefined) {
+      currentScope = new Scope(getActiveScope());
+      untrack(() => {
+        runInScope(currentScope, () => {
+          insertChild(frag, props.fallback);
+        });
+      });
+    }
+    currentContent = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope) {
+      currentScope.dispose();
+    }
+  });
+  return initialFrag;
+}
+function For(props) {
+  if (typeof document === "undefined") {
+    const list = resolveValue(props.each) ?? [];
+    if (list.length === 0) {
+      return props.fallback ?? null;
+    }
+    return list.map((item, idx) => props.children(item, () => idx));
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  let items = [];
+  let fallbackScope = null;
+  let fallbackNodes = [];
+  let isMounted = false;
+  effect(() => {
+    const list = resolveValue(props.each) ?? [];
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (list.length === 0) {
+      for (const rec of items) {
+        rec.scope.dispose();
+        for (const node of rec.nodes) {
+          if (node.parentNode)
+            node.parentNode.removeChild(node);
+        }
+      }
+      items = [];
+      if (props.fallback !== undefined && fallbackNodes.length === 0 && parent) {
+        fallbackScope = new Scope(getActiveScope());
+        untrack(() => {
+          runInScope(fallbackScope, () => {
+            const frag = document.createDocumentFragment();
+            insertChild(frag, props.fallback);
+            fallbackNodes = Array.from(frag.childNodes);
+            if (marker.parentNode) {
+              marker.parentNode.insertBefore(frag, marker);
+            } else if (!isMounted) {
+              initialFrag.appendChild(frag);
+            }
+          });
+        });
+      }
+      return;
+    }
+    if (fallbackNodes.length > 0) {
+      if (fallbackScope) {
+        fallbackScope.dispose();
+        fallbackScope = null;
+      }
+      for (const node of fallbackNodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+      fallbackNodes = [];
+    }
+    if (!parent)
+      return;
+    const newItems = [];
+    const prevMap = new Map;
+    for (const rec of items) {
+      prevMap.set(rec.item, rec);
+    }
+    for (let i = 0;i < list.length; i++) {
+      const item = list[i];
+      const existing = prevMap.get(item);
+      if (existing) {
+        existing.indexSignal(i);
+        newItems.push(existing);
+        prevMap.delete(item);
+      } else {
+        let indexVal = i;
+        const indexSubscribers = new Set;
+        const indexSignal = (...args) => {
+          if (args.length > 0 && args[0] !== undefined && args[0] !== indexVal) {
+            indexVal = args[0];
+            for (const sub of Array.from(indexSubscribers))
+              sub();
+          }
+          return indexVal;
+        };
+        const itemScope = new Scope(getActiveScope());
+        let itemNodes = [];
+        untrack(() => {
+          runInScope(itemScope, () => {
+            const frag = document.createDocumentFragment();
+            const child = props.children(item, indexSignal);
+            insertChild(frag, child);
+            itemNodes = Array.from(frag.childNodes);
+          });
+        });
+        newItems.push({
+          item,
+          scope: itemScope,
+          nodes: itemNodes,
+          indexSignal
+        });
+      }
+    }
+    for (const [, removed] of prevMap) {
+      removed.scope.dispose();
+      for (const node of removed.nodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+    }
+    if (marker.parentNode) {
+      let currentMarker = marker;
+      for (let i = newItems.length - 1;i >= 0; i--) {
+        const rec = newItems[i];
+        for (let j = rec.nodes.length - 1;j >= 0; j--) {
+          const node = rec.nodes[j];
+          if (node.nextSibling !== currentMarker) {
+            marker.parentNode.insertBefore(node, currentMarker);
+          }
+          currentMarker = node;
+        }
+      }
+    } else if (!isMounted) {
+      for (const rec of newItems) {
+        for (const node of rec.nodes) {
+          initialFrag.appendChild(node);
+        }
+      }
+    }
+    items = newItems;
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    for (const rec of items) {
+      rec.scope.dispose();
+    }
+    if (fallbackScope) {
+      fallbackScope.dispose();
+    }
+  });
+  return initialFrag;
+}
+function Portal(props) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const marker = document.createTextNode("");
+  let currentScope = null;
+  let nodes = [];
+  effect(() => {
+    const target = props.mount ?? (typeof document !== "undefined" ? document.body : null);
+    if (!target)
+      return;
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+    currentScope = new Scope(getActiveScope());
+    untrack(() => {
+      runInScope(currentScope, () => {
+        const childRes = typeof props.children === "function" ? props.children() : props.children;
+        const frag = document.createDocumentFragment();
+        insertChild(frag, childRes);
+        nodes = Array.from(frag.childNodes);
+        target.appendChild(frag);
+      });
+    });
+  });
+  onCleanup(() => {
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+  });
+  return marker;
+}
+// src/jsx-runtime/index.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "g",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "defs",
+  "clipPath",
+  "linearGradient",
+  "radialGradient",
+  "stop"
+]);
+function Fragment(props) {
+  if (typeof document === "undefined") {
+    return props.children !== undefined ? props.children : [];
+  }
+  const fragment = document.createDocumentFragment();
+  if (props.children !== undefined) {
+    insertChild(fragment, props.children);
+  }
+  return fragment;
+}
+function jsx(type, props = {}, key) {
+  if (typeof type === "function") {
+    return type(props, key);
+  }
+  if (typeof type === "string") {
+    const { children, ...restProps } = props;
+    if (typeof document === "undefined") {
+      const attributes = new Map;
+      for (const propName in restProps) {
+        const val = restProps[propName];
+        if (propName === "className" || propName === "class") {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved)
+            attributes.set("class", resolved);
+        } else if (propName === "style") {
+          const val = restProps[propName];
+          const resolved = resolveValue(val);
+          if (typeof resolved === "string") {
+            attributes.set("style", resolved);
+          } else if (typeof resolved === "object" && resolved !== null) {
+            const styleStr = Object.entries(resolved).map(([k, v]) => {
+              const finalVal = resolveValue(v);
+              const formatted = formatStyleProp(k, finalVal);
+              if (!formatted)
+                return "";
+              const kebab = k.startsWith("--") ? k : k.replace(/([A-Z])/g, "-$1").toLowerCase();
+              return `${kebab}: ${formatted}`;
+            }).filter(Boolean).join("; ");
+            if (styleStr)
+              attributes.set("style", styleStr);
+          }
+        } else if (!propName.startsWith("on")) {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved === true) {
+            attributes.set(propName, propName);
+          } else if (resolved !== false && resolved !== null && resolved !== undefined) {
+            attributes.set(propName, resolved);
+          }
+        }
+      }
+      const childNodes = children !== undefined ? Array.isArray(children) ? children : [children] : [];
+      return {
+        tagName: type,
+        attributes,
+        childNodes
+      };
+    }
+    const isSvg = SVG_TAGS.has(type);
+    const element = isSvg ? document.createElementNS(SVG_NS, type) : document.createElement(type);
+    for (const propName in restProps) {
+      setAttribute(element, propName, restProps[propName]);
+    }
+    if (children !== undefined) {
+      insertChild(element, children);
+    }
+    return element;
+  }
+  return type;
+}
+var jsxs = jsx;
+var jsxDEV = jsx;
+
+// src/charts/Area.tsx
+function Area(props) {
+  return () => {
+    const ctx = useChartContext();
+    const stroke = props.stroke ?? "#a855f7";
+    const strokeWidth = props.strokeWidth ?? 2;
+    const fill = props.fill ?? "rgba(168, 85, 247, 0.15)";
+    const fillOpacity = props.fillOpacity ?? 1;
+    const curve = props.curve ?? "smooth";
+    const id = `area-${props.dataKey}-${Math.random().toString(36).slice(2, 7)}`;
+    ctx.registerSeries({
+      id,
+      dataKey: props.dataKey,
+      type: "area",
+      color: stroke,
+      name: props.name ?? props.dataKey
+    });
+    onCleanup(() => {
+      ctx.unregisterSeries(id);
+    });
+    return /* @__PURE__ */ jsx("g", {
+      class: `visage-area-${props.dataKey}`,
+      opacity: props.opacity ?? 1,
+      children: () => {
+        const dataArr = ctx.data();
+        if (dataArr.length === 0)
+          return null;
+        const xScale = ctx.xScale();
+        const yScale = ctx.yScale();
+        const baselineY = ctx.innerHeight();
+        const points = [];
+        for (let i = 0;i < dataArr.length; i++) {
+          const item = dataArr[i];
+          const val = item[props.dataKey];
+          if (typeof val !== "number" || Number.isNaN(val))
+            continue;
+          let x = 0;
+          if (xScale.type === "band") {
+            x = xScale(i) + xScale.bandwidth() / 2;
+          } else {
+            x = xScale(i);
+          }
+          const y = yScale(val);
+          points.push({ x, y });
+        }
+        const areaD = pathArea(points, baselineY, { curve });
+        const lineD = pathLine(points, { curve });
+        const dots = [];
+        if (props.dot && points.length > 0) {
+          const dotCfg = typeof props.dot === "object" ? props.dot : {};
+          const r = dotCfg.r ?? 3.5;
+          const dotFill = dotCfg.fill ?? "#ffffff";
+          const dotStroke = dotCfg.stroke ?? stroke;
+          for (let i = 0;i < points.length; i++) {
+            const p = points[i];
+            dots.push(/* @__PURE__ */ jsx("circle", {
+              cx: p.x,
+              cy: p.y,
+              r,
+              fill: dotFill,
+              stroke: dotStroke,
+              "stroke-width": 2
+            }));
+          }
+        }
+        return [
+          /* @__PURE__ */ jsx("path", {
+            d: areaD,
+            fill,
+            "fill-opacity": fillOpacity
+          }),
+          /* @__PURE__ */ jsx("path", {
+            d: lineD,
+            fill: "none",
+            stroke,
+            "stroke-width": strokeWidth,
+            "stroke-linejoin": "round",
+            "stroke-linecap": "round"
+          }),
+          ...dots
+        ];
+      }
+    });
+  };
+}
+// src/charts/Axis.tsx
+function XAxis(props) {
+  return () => {
+    const ctx = useChartContext();
+    if (props.dataKey) {
+      ctx.setXDataKey(props.dataKey);
+      onCleanup(() => {
+        if (ctx.xDataKey() === props.dataKey) {
+          ctx.setXDataKey("");
+        }
+      });
+    }
+    const stroke = props.stroke ?? "#94a3b8";
+    const fontSize = props.fontSize ?? 11;
+    const hideLine = props.hideLine ?? false;
+    const w = ctx.innerWidth();
+    const h = ctx.innerHeight();
+    const xScale = ctx.xScale();
+    const dataArr = ctx.data();
+    const elements = [];
+    if (!hideLine) {
+      elements.push(/* @__PURE__ */ jsx("line", {
+        x1: 0,
+        y1: h,
+        x2: w,
+        y2: h,
+        stroke,
+        "stroke-width": 1
+      }));
+    }
+    if (xScale.type === "band") {
+      const ticks = xScale.ticks();
+      const bw = xScale.bandwidth();
+      for (let i = 0;i < ticks.length; i++) {
+        const val = ticks[i];
+        const x = xScale(i) + bw / 2;
+        const text = props.tickFormat ? props.tickFormat(val, i) : String(val);
+        elements.push(/* @__PURE__ */ jsx("text", {
+          x,
+          y: h + 16,
+          "text-anchor": "middle",
+          "font-size": fontSize,
+          fill: stroke,
+          children: text
+        }));
+      }
+    } else {
+      const count = props.tickCount ?? 5;
+      const ticks = xScale.ticks(count);
+      for (let i = 0;i < ticks.length; i++) {
+        const tickIdx = ticks[i];
+        const x = xScale(tickIdx);
+        const idx = Math.max(0, Math.min(dataArr.length - 1, Math.round(tickIdx)));
+        const rawItem = dataArr[idx];
+        const rawVal = props.dataKey && rawItem ? rawItem[props.dataKey] : idx;
+        const text = props.tickFormat ? props.tickFormat(rawVal, i) : String(rawVal ?? idx);
+        elements.push(/* @__PURE__ */ jsx("text", {
+          x,
+          y: h + 16,
+          "text-anchor": "middle",
+          "font-size": fontSize,
+          fill: stroke,
+          children: text
+        }));
+      }
+    }
+    return /* @__PURE__ */ jsx("g", {
+      class: "visage-x-axis",
+      children: elements
+    });
+  };
+}
+function YAxis(props) {
+  return () => {
+    const ctx = useChartContext();
+    const stroke = props.stroke ?? "#94a3b8";
+    const fontSize = props.fontSize ?? 11;
+    const hideLine = props.hideLine ?? true;
+    const unit = props.unit ?? "";
+    const h = ctx.innerHeight();
+    const yScale = ctx.yScale();
+    const ticks = yScale.ticks(props.tickCount ?? 5);
+    const elements = [];
+    if (!hideLine) {
+      elements.push(/* @__PURE__ */ jsx("line", {
+        x1: 0,
+        y1: 0,
+        x2: 0,
+        y2: h,
+        stroke,
+        "stroke-width": 1
+      }));
+    }
+    for (let i = 0;i < ticks.length; i++) {
+      const val = ticks[i];
+      const y = yScale(val);
+      const formatted = props.tickFormat ? props.tickFormat(val, i) : unit ? `${val}${unit}` : String(val);
+      elements.push(/* @__PURE__ */ jsx("text", {
+        x: -8,
+        y: y + 4,
+        "text-anchor": "end",
+        "font-size": fontSize,
+        fill: stroke,
+        children: formatted
+      }));
+    }
+    return /* @__PURE__ */ jsx("g", {
+      class: "visage-y-axis",
+      children: elements
+    });
+  };
+}
+// src/charts/Bar.tsx
+function Bar(props) {
+  return () => {
+    const ctx = useChartContext();
+    const fill = props.fill ?? "#6366f1";
+    const radius = props.radius ?? 4;
+    const id = `bar-${props.dataKey}-${Math.random().toString(36).slice(2, 7)}`;
+    ctx.registerSeries({
+      id,
+      dataKey: props.dataKey,
+      type: "bar",
+      color: fill,
+      name: props.name ?? props.dataKey
+    });
+    onCleanup(() => {
+      ctx.unregisterSeries(id);
+    });
+    return /* @__PURE__ */ jsx("g", {
+      class: `visage-bar-${props.dataKey}`,
+      opacity: props.opacity ?? 1,
+      children: () => {
+        const dataArr = ctx.data();
+        if (dataArr.length === 0)
+          return null;
+        const xScale = ctx.xScale();
+        const yScale = ctx.yScale();
+        const baselineY = ctx.innerHeight();
+        const allBars = ctx.series().filter((s) => s.type === "bar");
+        const barIndex = allBars.findIndex((s) => s.id === id);
+        const totalBars = Math.max(1, allBars.length);
+        const bars = [];
+        for (let i = 0;i < dataArr.length; i++) {
+          const item = dataArr[i];
+          const val = item[props.dataKey];
+          if (typeof val !== "number" || Number.isNaN(val))
+            continue;
+          let slotX = 0;
+          let slotW = 20;
+          if (xScale.type === "band") {
+            slotX = xScale(i);
+            slotW = xScale.bandwidth();
+          } else {
+            const stepW = ctx.innerWidth() / Math.max(1, dataArr.length);
+            slotX = xScale(i) - stepW / 2;
+            slotW = stepW * 0.8;
+          }
+          const subBarW = slotW / totalBars;
+          const barW = props.maxWidth ? Math.min(props.maxWidth, subBarW) : subBarW;
+          const barX = slotX + (barIndex >= 0 ? barIndex * subBarW : 0) + (subBarW - barW) / 2;
+          const y = yScale(val);
+          const h = Math.max(0, baselineY - y);
+          bars.push(/* @__PURE__ */ jsx("rect", {
+            x: barX,
+            y,
+            width: barW,
+            height: h,
+            rx: radius,
+            ry: radius,
+            fill
+          }));
+        }
+        return bars;
+      }
+    });
+  };
+}
+// src/charts/CartesianGrid.tsx
+function CartesianGrid(props) {
+  return () => {
+    const ctx = useChartContext();
+    const horizontal = props.horizontal ?? true;
+    const vertical = props.vertical ?? false;
+    const stroke = props.stroke ?? "#e2e8f0";
+    const strokeWidth = props.strokeWidth ?? 1;
+    const strokeDasharray = props.strokeDasharray;
+    const opacity = props.opacity ?? 0.8;
+    const lines = [];
+    const w = ctx.innerWidth();
+    const h = ctx.innerHeight();
+    const yScale = ctx.yScale();
+    const xScale = ctx.xScale();
+    if (horizontal) {
+      const ticks = yScale.ticks(5);
+      for (const t of ticks) {
+        const y = yScale(t);
+        lines.push(/* @__PURE__ */ jsx("line", {
+          x1: 0,
+          y1: y,
+          x2: w,
+          y2: y,
+          stroke,
+          "stroke-width": strokeWidth,
+          "stroke-dasharray": strokeDasharray
+        }));
+      }
+    }
+    if (vertical) {
+      const ticks = xScale.ticks(5);
+      for (const t of ticks) {
+        const x = xScale(t);
+        lines.push(/* @__PURE__ */ jsx("line", {
+          x1: x,
+          y1: 0,
+          x2: x,
+          y2: h,
+          stroke,
+          "stroke-width": strokeWidth,
+          "stroke-dasharray": strokeDasharray
+        }));
+      }
+    }
+    return /* @__PURE__ */ jsx("g", {
+      class: "visage-cartesian-grid",
+      opacity,
+      children: lines
+    });
+  };
+}
+// src/charts/scale.ts
+function generateNiceTicks(min, max, count = 5) {
+  if (min === max)
+    return [min];
+  if (count <= 0)
+    return [];
+  const span = max - min;
+  const rawStep = span / count;
+  const magnitude = 10 ** Math.floor(Math.log10(rawStep));
+  const err = rawStep / magnitude;
+  let step;
+  if (err >= 7.5) {
+    step = 10 * magnitude;
+  } else if (err >= 3.5) {
+    step = 5 * magnitude;
+  } else if (err >= 1.5) {
+    step = 2 * magnitude;
+  } else {
+    step = 1 * magnitude;
+  }
+  const start = Math.floor(min / step) * step;
+  const end = Math.ceil(max / step) * step;
+  const ticks = [];
+  for (let current = start;current <= end + step * 0.5; current += step) {
+    const rounded = Number(current.toPrecision(12));
+    ticks.push(rounded);
+  }
+  return ticks;
+}
+function createLinearScale(domain, range, options = {}) {
+  let [d0, d1] = domain;
+  const [r0, r1] = range;
+  if (options.nice && d0 !== d1) {
+    const ticks = generateNiceTicks(d0, d1, 5);
+    if (ticks.length > 0) {
+      d0 = Math.min(d0, ticks[0]);
+      d1 = Math.max(d1, ticks[ticks.length - 1]);
+    }
+  }
+  const fn = (val) => {
+    let v = val;
+    if (options.clamp) {
+      const minD = Math.min(d0, d1);
+      const maxD = Math.max(d0, d1);
+      v = Math.max(minD, Math.min(maxD, v));
+    }
+    const ratio = d1 === d0 ? 0 : (v - d0) / (d1 - d0);
+    return r0 + ratio * (r1 - r0);
+  };
+  fn.type = "linear";
+  fn.domain = [d0, d1];
+  fn.range = [r0, r1];
+  fn.invert = (pixel) => {
+    const ratio = r1 === r0 ? 0 : (pixel - r0) / (r1 - r0);
+    return d0 + ratio * (d1 - d0);
+  };
+  fn.ticks = (count = 5) => {
+    return generateNiceTicks(d0, d1, count);
+  };
+  return fn;
+}
+function createBandScale(domain, range, options = {}) {
+  const paddingInner = options.paddingInner ?? 0.2;
+  const paddingOuter = options.paddingOuter ?? 0.1;
+  const n = domain.length;
+  const totalSteps = Math.max(1, n - paddingInner + 2 * paddingOuter);
+  const step = (range[1] - range[0]) / totalSteps;
+  const bandwidth = step * (1 - paddingInner);
+  const fn = (val) => {
+    let idx = -1;
+    if (typeof val === "number" && Number.isInteger(val) && val >= 0 && val < domain.length) {
+      idx = val;
+    } else {
+      idx = domain.indexOf(val);
+    }
+    if (idx === -1)
+      return range[0];
+    return range[0] + (idx + paddingOuter) * step;
+  };
+  fn.type = "band";
+  fn.domain = [...domain];
+  fn.range = [range[0], range[1]];
+  fn.bandwidth = () => bandwidth;
+  fn.step = () => step;
+  fn.ticks = () => [...domain];
+  return fn;
+}
+
+// src/charts/Chart.tsx
+var DEFAULT_MARGIN = {
+  top: 16,
+  right: 16,
+  bottom: 24,
+  left: 36
+};
+function Chart(props) {
+  const margin = {
+    ...DEFAULT_MARGIN,
+    ...props.margin
+  };
+  const initialW = typeof props.width === "number" ? props.width : 500;
+  const initialH = typeof props.height === "number" ? props.height : 300;
+  const measuredWidth = signal(initialW);
+  const measuredHeight = signal(initialH);
+  let containerEl = null;
+  const handleRef = (el) => {
+    containerEl = el;
+    if (typeof ResizeObserver !== "undefined") {
+      const ro = new ResizeObserver((entries) => {
+        for (const entry of entries) {
+          const cr = entry.contentRect;
+          if (cr.width > 0)
+            measuredWidth.set(cr.width);
+          if (cr.height > 0)
+            measuredHeight.set(cr.height);
+        }
+      });
+      ro.observe(el);
+      onCleanup(() => ro.disconnect());
+    } else {
+      if (el.clientWidth > 0)
+        measuredWidth.set(el.clientWidth);
+      if (el.clientHeight > 0)
+        measuredHeight.set(el.clientHeight);
+    }
+  };
+  const innerWidth = computed(() => Math.max(10, measuredWidth() - margin.left - margin.right));
+  const innerHeight = computed(() => Math.max(10, measuredHeight() - margin.top - margin.bottom));
+  const rawData = () => resolveValue(props.data) || [];
+  const seriesList = signal([]);
+  const xDataKey = signal(undefined);
+  const registerSeries = (meta) => {
+    untrack(() => {
+      seriesList.update((prev) => {
+        if (prev.some((s) => s.id === meta.id))
+          return prev;
+        return [...prev, meta];
+      });
+    });
+  };
+  const unregisterSeries = (id) => {
+    untrack(() => {
+      seriesList.update((prev) => prev.filter((s) => s.id !== id));
+    });
+  };
+  const hoverState = signal({
+    active: false,
+    x: 0,
+    y: 0,
+    index: -1
+  });
+  const xScale = computed(() => {
+    const dataArr = rawData();
+    const w = innerWidth();
+    const key = xDataKey();
+    const hasBarSeries = untrack(() => seriesList().some((s) => s.type === "bar"));
+    if (hasBarSeries && key && dataArr.length > 0) {
+      const categories = dataArr.map((d) => String(d[key]));
+      return createBandScale(categories, [0, w], {
+        paddingInner: 0.1,
+        paddingOuter: 0.05
+      });
+    }
+    const maxIdx = Math.max(1, dataArr.length - 1);
+    return createLinearScale([0, maxIdx], [0, w]);
+  });
+  const yScale = computed(() => {
+    const h = innerHeight();
+    const dataArr = rawData();
+    const currentSeries = seriesList();
+    let minY = 0;
+    let maxY = 10;
+    if (props.yDomain) {
+      minY = props.yDomain[0];
+      maxY = props.yDomain[1];
+    } else if (dataArr.length > 0 && currentSeries.length > 0) {
+      let foundMin = Infinity;
+      let foundMax = -Infinity;
+      for (const item of dataArr) {
+        for (const s of currentSeries) {
+          const val = item[s.dataKey];
+          if (typeof val === "number" && !Number.isNaN(val)) {
+            if (val < foundMin)
+              foundMin = val;
+            if (val > foundMax)
+              foundMax = val;
+          }
+        }
+      }
+      if (foundMax > -Infinity) {
+        minY = Math.min(0, foundMin);
+        maxY = foundMax === 0 ? 1 : foundMax * 1.1;
+      }
+    }
+    return createLinearScale([minY, maxY], [h, 0], { nice: true });
+  });
+  const handlePointer = (clientX, clientY) => {
+    if (!containerEl)
+      return;
+    const rect = containerEl.getBoundingClientRect();
+    const relX = clientX - rect.left - margin.left;
+    const relY = clientY - rect.top - margin.top;
+    const w = innerWidth();
+    const h = innerHeight();
+    if (relX < 0 || relX > w || relY < 0 || relY > h) {
+      hoverState.set({ active: false, x: 0, y: 0, index: -1 });
+      return;
+    }
+    const dataArr = rawData();
+    if (dataArr.length === 0)
+      return;
+    const count = dataArr.length;
+    const stepW = w / Math.max(1, count - 1);
+    const rawIdx = Math.round(relX / stepW);
+    const clampedIdx = Math.max(0, Math.min(count - 1, rawIdx));
+    hoverState.set({
+      active: true,
+      x: relX + margin.left,
+      y: relY + margin.top,
+      index: clampedIdx,
+      datum: dataArr[clampedIdx]
+    });
+  };
+  const handleMouseMove = (e) => {
+    handlePointer(e.clientX, e.clientY);
+  };
+  const handleMouseLeave = () => {
+    hoverState.set({ active: false, x: 0, y: 0, index: -1 });
+  };
+  const handleTouchMove = (e) => {
+    const touch = e.touches[0];
+    if (touch)
+      handlePointer(touch.clientX, touch.clientY);
+  };
+  const handleTouchEnd = () => {
+    hoverState.set({ active: false, x: 0, y: 0, index: -1 });
+  };
+  const ctxValue = {
+    data: rawData,
+    width: () => measuredWidth(),
+    height: () => measuredHeight(),
+    margin,
+    innerWidth: () => innerWidth(),
+    innerHeight: () => innerHeight(),
+    xScale: () => xScale(),
+    yScale: () => yScale(),
+    hoverState: () => hoverState(),
+    setHoverState: (s) => hoverState.set(s),
+    xDataKey: () => xDataKey(),
+    setXDataKey: (k) => xDataKey.set(k),
+    series: () => seriesList(),
+    registerSeries,
+    unregisterSeries
+  };
+  const containerStyle = {
+    position: "relative",
+    width: typeof props.width === "number" ? `${props.width}px` : props.width ?? "100%",
+    height: typeof props.height === "number" ? `${props.height}px` : props.height ?? "300px",
+    touchAction: "none",
+    userSelect: "none",
+    ...props.style
+  };
+  const rawChildren = Array.isArray(props.children) ? props.children : [props.children];
+  const childrenList = [];
+  const stack = [...rawChildren];
+  while (stack.length > 0) {
+    const item = stack.shift();
+    if (Array.isArray(item)) {
+      stack.unshift(...item);
+    } else if (item !== null && item !== undefined && item !== false) {
+      childrenList.push(item);
+    }
+  }
+  const svgChildren = [];
+  const overlayChildren = [];
+  for (const child of childrenList) {
+    if (typeof child === "function" && child.__visage_overlay) {
+      overlayChildren.push(child);
+    } else {
+      svgChildren.push(child);
+    }
+  }
+  return ChartContext.Provider({
+    value: ctxValue,
+    children: () => /* @__PURE__ */ jsxs("div", {
+      ref: handleRef,
+      class: props.class || props.className,
+      style: containerStyle,
+      onMouseMove: handleMouseMove,
+      onMouseLeave: handleMouseLeave,
+      onTouchMove: handleTouchMove,
+      onTouchEnd: handleTouchEnd,
+      children: [
+        /* @__PURE__ */ jsxs("svg", {
+          role: "img",
+          "aria-label": props["aria-label"] ?? "Data visualization chart",
+          viewBox: () => `0 0 ${measuredWidth()} ${measuredHeight()}`,
+          width: "100%",
+          height: "100%",
+          style: { overflow: "visible", display: "block" },
+          children: [
+            /* @__PURE__ */ jsx("title", {
+              children: props.title ?? "Data Visualization Chart"
+            }),
+            /* @__PURE__ */ jsx("g", {
+              transform: `translate(${margin.left}, ${margin.top})`,
+              children: svgChildren
+            })
+          ]
+        }),
+        overlayChildren
+      ]
+    })
+  });
+}
+// src/charts/Cursor.tsx
+function ChartCursor(props) {
+  return () => {
+    const ctx = useChartContext();
+    const stroke = props.stroke ?? "#94a3b8";
+    const strokeWidth = props.strokeWidth ?? 1;
+    const strokeDasharray = props.strokeDasharray ?? "4 4";
+    const opacity = props.opacity ?? 0.8;
+    const hover = ctx.hoverState();
+    if (!hover.active)
+      return null;
+    const h = ctx.innerHeight();
+    const x = hover.x - ctx.margin.left;
+    return /* @__PURE__ */ jsx("g", {
+      class: "visage-chart-cursor",
+      children: /* @__PURE__ */ jsx("line", {
+        x1: x,
+        y1: 0,
+        x2: x,
+        y2: h,
+        stroke,
+        "stroke-width": strokeWidth,
+        "stroke-dasharray": strokeDasharray,
+        opacity
+      })
+    });
+  };
+}
+// src/charts/Legend.tsx
+function ChartLegend(props) {
+  const render = () => {
+    const ctx = useChartContext();
+    const align = props.align ?? "center";
+    const justifyMap = {
+      left: "flex-start",
+      center: "center",
+      right: "flex-end"
+    };
+    const series = ctx.series();
+    return /* @__PURE__ */ jsx("div", {
+      class: props.class || props.className,
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: justifyMap[align],
+        gap: "16px",
+        paddingTop: "8px",
+        fontSize: "12px",
+        color: "#475569"
+      },
+      children: series.map((s) => /* @__PURE__ */ jsxs("div", {
+        style: { display: "flex", alignItems: "center", gap: "6px" },
+        children: [
+          /* @__PURE__ */ jsx("span", {
+            style: {
+              width: "10px",
+              height: "10px",
+              borderRadius: "3px",
+              background: s.color ?? "#8b5cf6"
+            }
+          }),
+          /* @__PURE__ */ jsx("span", {
+            children: s.name ?? s.dataKey
+          })
+        ]
+      }))
+    });
+  };
+  render.__visage_overlay = true;
+  return render;
+}
+var Legend = ChartLegend;
+// src/charts/Line.tsx
+function Line(props) {
+  return () => {
+    const ctx = useChartContext();
+    const stroke = props.stroke ?? "#8b5cf6";
+    const strokeWidth = props.strokeWidth ?? 2;
+    const curve = props.curve ?? "linear";
+    const id = `line-${props.dataKey}-${Math.random().toString(36).slice(2, 7)}`;
+    ctx.registerSeries({
+      id,
+      dataKey: props.dataKey,
+      type: "line",
+      color: stroke,
+      name: props.name ?? props.dataKey
+    });
+    onCleanup(() => {
+      ctx.unregisterSeries(id);
+    });
+    return /* @__PURE__ */ jsx("g", {
+      class: `visage-line-${props.dataKey}`,
+      opacity: props.opacity ?? 1,
+      children: () => {
+        const dataArr = ctx.data();
+        if (dataArr.length === 0)
+          return null;
+        const xScale = ctx.xScale();
+        const yScale = ctx.yScale();
+        const points = [];
+        for (let i = 0;i < dataArr.length; i++) {
+          const item = dataArr[i];
+          const val = item[props.dataKey];
+          if (typeof val !== "number" || Number.isNaN(val))
+            continue;
+          let x = 0;
+          if (xScale.type === "band") {
+            x = xScale(i) + xScale.bandwidth() / 2;
+          } else {
+            x = xScale(i);
+          }
+          const y = yScale(val);
+          points.push({ x, y });
+        }
+        const d = pathLine(points, { curve });
+        const dots = [];
+        if (props.dot && points.length > 0) {
+          const dotCfg = typeof props.dot === "object" ? props.dot : {};
+          const r = dotCfg.r ?? 3.5;
+          const fill = dotCfg.fill ?? "#ffffff";
+          const dotStroke = dotCfg.stroke ?? stroke;
+          const dotSw = dotCfg.strokeWidth ?? 2;
+          for (let i = 0;i < points.length; i++) {
+            const p = points[i];
+            dots.push(/* @__PURE__ */ jsx("circle", {
+              cx: p.x,
+              cy: p.y,
+              r,
+              fill,
+              stroke: dotStroke,
+              "stroke-width": dotSw
+            }));
+          }
+        }
+        return [
+          /* @__PURE__ */ jsx("path", {
+            d,
+            fill: "none",
+            stroke,
+            "stroke-width": strokeWidth,
+            "stroke-dasharray": props.strokeDasharray,
+            "stroke-linejoin": "round",
+            "stroke-linecap": "round"
+          }),
+          ...dots
+        ];
+      }
+    });
+  };
+}
+// src/charts/Pie.tsx
+var DEFAULT_PALETTE = [
+  "#8b5cf6",
+  "#ec4899",
+  "#3b82f6",
+  "#10b981",
+  "#f59e0b",
+  "#6366f1",
+  "#14b8a6",
+  "#ef4444"
+];
+function Pie(props) {
+  return () => {
+    const ctx = useChartContext();
+    const innerRadius = props.innerRadius ?? 0;
+    const outerRadius = props.outerRadius ?? 80;
+    const colors = props.colors ?? DEFAULT_PALETTE;
+    const padAngle = props.padAngle ?? 0.02;
+    return /* @__PURE__ */ jsx("g", {
+      class: "visage-pie",
+      children: () => {
+        const dataArr = ctx.data();
+        if (dataArr.length === 0)
+          return null;
+        const w = ctx.innerWidth();
+        const h = ctx.innerHeight();
+        const centerX = props.cx ?? w / 2;
+        const centerY = props.cy ?? h / 2;
+        let total = 0;
+        for (const item of dataArr) {
+          const val = Number(item[props.dataKey]) || 0;
+          total += val;
+        }
+        if (total === 0)
+          return null;
+        const slices = [];
+        let currentAngle = -Math.PI / 2;
+        for (let i = 0;i < dataArr.length; i++) {
+          const item = dataArr[i];
+          const val = Number(item[props.dataKey]) || 0;
+          const sliceAngle = val / total * (2 * Math.PI);
+          const startAngle = currentAngle + (val > 0 ? padAngle / 2 : 0);
+          const endAngle = currentAngle + sliceAngle - (val > 0 ? padAngle / 2 : 0);
+          currentAngle += sliceAngle;
+          if (val <= 0 || endAngle <= startAngle)
+            continue;
+          const d = pathArc({
+            cx: centerX,
+            cy: centerY,
+            innerRadius,
+            outerRadius,
+            startAngle,
+            endAngle
+          });
+          const fill = colors[i % colors.length];
+          slices.push(/* @__PURE__ */ jsx("path", {
+            d,
+            fill,
+            stroke: "#ffffff",
+            "stroke-width": 1.5
+          }));
+        }
+        return slices;
+      }
+    });
+  };
+}
+// src/charts/Tooltip.tsx
+function ChartTooltip(props) {
+  const render = () => {
+    const ctx = useChartContext();
+    const hover = ctx.hoverState();
+    if (!hover.active || !hover.datum)
+      return null;
+    const w = ctx.width();
+    const datum = hover.datum;
+    const series = ctx.series();
+    const xKey = ctx.xDataKey();
+    const cardWidth = 160;
+    let left = hover.x + 14;
+    if (left + cardWidth > w) {
+      left = Math.max(10, hover.x - cardWidth - 14);
+    }
+    const top = Math.max(10, hover.y - 30);
+    if (props.content) {
+      return /* @__PURE__ */ jsx("div", {
+        style: {
+          position: "absolute",
+          left: `${left}px`,
+          top: `${top}px`,
+          pointerEvents: "none",
+          zIndex: 50
+        },
+        children: props.content(datum, series)
+      });
+    }
+    const label = xKey && datum[xKey] !== undefined ? datum[xKey] : `#${hover.index + 1}`;
+    const formattedLabel = props.labelFormat ? props.labelFormat(label) : String(label);
+    return /* @__PURE__ */ jsxs("div", {
+      class: props.class || props.className,
+      style: {
+        position: "absolute",
+        left: `${left}px`,
+        top: `${top}px`,
+        pointerEvents: "none",
+        zIndex: 50,
+        minWidth: `${cardWidth}px`,
+        padding: "8px 12px",
+        borderRadius: "10px",
+        background: "rgba(255, 255, 255, 0.92)",
+        backdropFilter: "blur(12px)",
+        WebkitBackdropFilter: "blur(12px)",
+        border: "1px solid rgba(226, 232, 240, 0.8)",
+        boxShadow: "0 10px 15px -3px rgba(0, 0, 0, 0.08), 0 4px 6px -4px rgba(0, 0, 0, 0.05)",
+        fontSize: "12px",
+        color: "#1e293b",
+        lineHeight: "1.4"
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", {
+          style: {
+            fontWeight: "600",
+            color: "#475569",
+            marginBottom: "6px",
+            borderBottom: "1px solid #f1f5f9",
+            paddingBottom: "4px"
+          },
+          children: formattedLabel
+        }),
+        /* @__PURE__ */ jsx("div", {
+          style: { display: "flex", flexDirection: "column", gap: "4px" },
+          children: series.map((s) => {
+            const rawVal = datum[s.dataKey];
+            if (rawVal === undefined || rawVal === null)
+              return null;
+            const valStr = props.format ? props.format(rawVal, s.name ?? s.dataKey) : String(rawVal);
+            return /* @__PURE__ */ jsxs("div", {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "space-between",
+                gap: "8px"
+              },
+              children: [
+                /* @__PURE__ */ jsxs("div", {
+                  style: { display: "flex", alignItems: "center", gap: "6px" },
+                  children: [
+                    /* @__PURE__ */ jsx("span", {
+                      style: {
+                        width: "8px",
+                        height: "8px",
+                        borderRadius: "50%",
+                        background: s.color ?? "#8b5cf6"
+                      }
+                    }),
+                    /* @__PURE__ */ jsx("span", {
+                      style: { color: "#64748b" },
+                      children: s.name ?? s.dataKey
+                    })
+                  ]
+                }),
+                /* @__PURE__ */ jsx("span", {
+                  style: { fontWeight: "600", color: "#0f172a" },
+                  children: valStr
+                })
+              ]
+            });
+          })
+        })
+      ]
+    });
+  };
+  render.__visage_overlay = true;
+  return render;
+}
+var Tooltip = ChartTooltip;
+export {
+  Area,
+  Bar,
+  CartesianGrid,
+  Chart,
+  ChartContext,
+  ChartCursor,
+  ChartLegend,
+  ChartTooltip,
+  Legend,
+  Line,
+  Pie,
+  Tooltip,
+  XAxis,
+  YAxis,
+  createBandScale,
+  createLinearScale,
+  generateNiceTicks,
+  pathArc,
+  pathArea,
+  pathLine,
+  useChartContext
+};