@birdapi/velinstyle 1.2.1 → 1.3.0

package/dist/chunks/attributes-HK7VIOLA.js

@@ -0,0 +1,1080 @@
+import {
+  disconnectInViewObserver,
+  observeInView
+} from "./chunk-7MCGPHVC.js";
+import {
+  lazyDefine
+} from "./chunk-MYKUI364.js";
+
+// core/motion/effects.js
+var VISIBLE_CLASS = "velin-in-view";
+var EFFECT_MAP = {
+  reveal: ["velin-animate-on-scroll"],
+  fade: ["velin-animate-on-scroll", "velin-animate-on-scroll--fade"],
+  slide: ["velin-animate-on-scroll", "velin-animate-on-scroll--slide-up"],
+  "slide-up": ["velin-animate-on-scroll", "velin-animate-on-scroll--slide-up"],
+  "slide-down": ["velin-animate-on-scroll", "velin-animate-on-scroll--slide-down"],
+  "slide-left": ["velin-animate-on-scroll", "velin-animate-on-scroll--slide-left"],
+  "slide-right": ["velin-animate-on-scroll", "velin-animate-on-scroll--slide-right"],
+  scale: ["velin-animate-on-scroll", "velin-animate-on-scroll--scale"],
+  zoom: ["velin-animate-on-scroll", "velin-animate-on-scroll--scale"],
+  parallax: ["velin-parallax"],
+  "parallax-slow": ["velin-parallax", "velin-parallax--slow"],
+  hover: ["velin-animate-hover"],
+  "hover-lift": ["velin-animate-hover"],
+  lift: ["velin-animate-hover"],
+  flip: ["velin-animate-scale-in"],
+  blur: ["velin-animate-fade-in"],
+  pulse: ["velin-animate-pulse"],
+  shake: ["velin-animate-shake"],
+  bounce: ["velin-animate-bounce"],
+  shimmer: ["velin-skeleton"],
+  heroReveal: ["velin-animate-on-scroll", "velin-animate-on-scroll--fade"],
+  fadeOut: ["velin-animate-fade-out"]
+};
+function applyEffects(el, attrs = {}) {
+  const classes = /* @__PURE__ */ new Set();
+  for (const [name, value] of Object.entries(attrs)) {
+    if (value === "false" || value === "off") continue;
+    if (name === "motion" && value && value !== "true") {
+      const presetKey = value;
+      const mapped2 = EFFECT_MAP[presetKey];
+      if (mapped2) mapped2.forEach((c) => classes.add(c));
+      continue;
+    }
+    const mapped = EFFECT_MAP[name];
+    if (mapped) mapped.forEach((c) => classes.add(c));
+    if (name === "slide" && value && value !== "true" && value !== "") {
+      const key = `slide-${value}`;
+      EFFECT_MAP[key]?.forEach((c) => classes.add(c));
+    }
+  }
+  classes.forEach((c) => el.classList.add(c));
+  if (!el.classList.contains("velin-animate-on-scroll") && attrs.reveal !== void 0) {
+    el.classList.add("velin-animate-on-scroll");
+  }
+  return [...classes];
+}
+function markVisible(el) {
+  el.classList.add(VISIBLE_CLASS);
+  el.dataset.velinVisible = "true";
+}
+function prefersReducedMotion() {
+  return typeof window !== "undefined" && window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+// core/motion/stagger.js
+var STAGGER_ATTR = "velin-stagger";
+function applyStagger(listEl, value = "true") {
+  const base = value === "true" || value === "" ? 60 : parseInt(value, 10) || 60;
+  const children = [...listEl.children];
+  children.forEach((child, i) => {
+    child.style.setProperty("--velin-stagger-delay", `${i * base}ms`);
+    child.classList.add("velin-stagger-item");
+  });
+  listEl.classList.add("velin-stagger");
+}
+function enhanceStagger(root = document) {
+  root.querySelectorAll(`[${STAGGER_ATTR}]`).forEach((el) => {
+    if (el.dataset.velinStaggerDone) return;
+    el.dataset.velinStaggerDone = "1";
+    applyStagger(el, el.getAttribute(STAGGER_ATTR) || "true");
+  });
+}
+
+// core/motion/scroll.js
+function smoothScrollTo(target, options = {}) {
+  const reduced = typeof window !== "undefined" && window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const el = typeof target === "string" ? document.querySelector(target) : target;
+  if (!el) return;
+  el.scrollIntoView({
+    behavior: reduced || options.instant ? "auto" : "smooth",
+    block: options.block || "start",
+    inline: options.inline || "nearest"
+  });
+  if (el.tabIndex < 0 && !el.hasAttribute("tabindex")) {
+    el.setAttribute("tabindex", "-1");
+  }
+  el.focus({ preventScroll: true });
+}
+function bindSmoothScroll(root = document) {
+  root.querySelectorAll("[velin-scroll]").forEach((link) => {
+    if (link.dataset.velinScrollBound) return;
+    link.dataset.velinScrollBound = "1";
+    link.addEventListener("click", (e) => {
+      const href = link.getAttribute("href");
+      if (!href || !href.startsWith("#")) return;
+      const target = document.querySelector(href);
+      if (!target) return;
+      e.preventDefault();
+      smoothScrollTo(target);
+    });
+  });
+}
+
+// core/motion/data/registry.json
+var registry_default = {
+  schema: "velinstyle.motion.registry",
+  version: 1,
+  presets: [
+    {
+      id: "fade",
+      title: "Fade",
+      description: "Opacity entrance; layout-safe default reveal.",
+      kind: "preset",
+      category: "hero",
+      tags: ["entrance"],
+      duration: 400,
+      fps: "60",
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--fade",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "slide",
+      title: "Slide Up",
+      description: "Slide from below into view.",
+      kind: "preset",
+      category: "cards",
+      tags: ["entrance", "slide"],
+      duration: 500,
+      fps: "60",
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--slide-up",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "slide-down",
+      title: "Slide Down",
+      description: "Slide from above into view.",
+      kind: "preset",
+      category: "navigation",
+      tags: ["entrance", "slide"],
+      duration: 500,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--slide-down",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "slide-left",
+      title: "Slide Left",
+      description: "Slide from the inline-end.",
+      kind: "preset",
+      category: "lists",
+      tags: ["entrance", "slide"],
+      duration: 500,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--slide-left",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "slide-right",
+      title: "Slide Right",
+      description: "Slide from the inline-start.",
+      kind: "preset",
+      category: "lists",
+      tags: ["entrance", "slide"],
+      duration: 500,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--slide-right",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "zoom",
+      title: "Zoom / Scale",
+      description: "Scale-in entrance for cards and media.",
+      kind: "preset",
+      category: "media",
+      tags: ["entrance", "scale"],
+      duration: 450,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--scale",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "blur",
+      title: "Blur In",
+      description: "Soft fade/blur entrance (maps to fade-in utility).",
+      kind: "preset",
+      category: "overlay",
+      tags: ["entrance"],
+      duration: 500,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "beta",
+      cssClass: "velin-animate-fade-in",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "flip",
+      title: "Flip / Scale In",
+      description: "Attention scale-in for emphasis.",
+      kind: "preset",
+      category: "feedback",
+      tags: ["attention"],
+      duration: 400,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "beta",
+      cssClass: "velin-animate-scale-in",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "lift",
+      title: "Hover Lift",
+      description: "Subtle lift on hover for interactive cards and buttons.",
+      kind: "preset",
+      category: "buttons",
+      tags: ["hover"],
+      duration: 200,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-hover",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "pulse",
+      title: "Pulse",
+      description: "Attention pulse; prefer finite loops under performance policy.",
+      kind: "preset",
+      category: "feedback",
+      tags: ["attention"],
+      duration: 1e3,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-pulse",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "shake",
+      title: "Shake",
+      description: "Error/attention shake feedback.",
+      kind: "preset",
+      category: "forms",
+      tags: ["attention", "feedback"],
+      duration: 400,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-shake",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "bounce",
+      title: "Bounce",
+      description: "Playful bounce entrance or attention.",
+      kind: "preset",
+      category: "feedback",
+      tags: ["attention"],
+      duration: 600,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-bounce",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "shimmer",
+      title: "Shimmer",
+      description: "Loading shimmer surface (skeleton companion).",
+      kind: "preset",
+      category: "loading",
+      tags: ["loading"],
+      duration: 1200,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-skeleton",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "heroReveal",
+      title: "Hero Reveal",
+      description: "Staggered entrance for hero content; layout-safe; reduced-motion fallback.",
+      kind: "preset",
+      category: "hero",
+      tags: ["entrance", "stagger"],
+      duration: 600,
+      fps: "60",
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "stable",
+      cssClass: "velin-animate-on-scroll--fade",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "parallax",
+      title: "Parallax",
+      description: "Scroll-driven parallax shift.",
+      kind: "preset",
+      category: "media",
+      tags: ["scroll"],
+      duration: 0,
+      reducedMotion: true,
+      layoutSafe: false,
+      status: "stable",
+      cssClass: "velin-parallax",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "fadeOut",
+      title: "Fade Out",
+      description: "Exit fade (planned composition with timelines).",
+      kind: "preset",
+      category: "overlay",
+      tags: ["exit"],
+      duration: 300,
+      reducedMotion: true,
+      layoutSafe: true,
+      status: "beta",
+      cssClass: "velin-animate-fade-out",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    }
+  ],
+  timelines: [
+    {
+      id: "hero-intro",
+      title: "Hero Intro",
+      description: "Title \u2192 subtitle \u2192 buttons \u2192 image",
+      kind: "timeline",
+      category: "hero",
+      steps: ["title", "subtitle", "buttons", "image"],
+      status: "beta",
+      compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "card-stagger",
+      title: "Card Stagger",
+      description: "Sequential card entrance labels.",
+      kind: "timeline",
+      category: "cards",
+      steps: ["card-1", "card-2", "card-3"],
+      status: "beta",
+      compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    }
+  ],
+  transitions: [
+    {
+      id: "cross-fade",
+      title: "Cross Fade",
+      description: "Page/view cross-fade (View Transition friendly).",
+      kind: "transition",
+      category: "page",
+      status: "planned",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "modal-enter",
+      title: "Modal Enter",
+      description: "Overlay modal entrance transition.",
+      kind: "transition",
+      category: "modal",
+      status: "planned",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "drawer-enter",
+      title: "Drawer Enter",
+      description: "Drawer slide transition.",
+      kind: "transition",
+      category: "drawer",
+      status: "planned",
+      compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    }
+  ],
+  physics: [
+    {
+      id: "spring",
+      title: "Spring",
+      description: "Spring easing token mapping (runtime simulation later).",
+      kind: "physics",
+      category: "feedback",
+      status: "planned",
+      token: "--velin-ease-spring",
+      compatibility: { cssOnly: true, runtime: false, webComponents: false, studio: true, production: true, review: true, cli: true }
+    },
+    {
+      id: "elastic",
+      title: "Elastic",
+      description: "Elastic easing token mapping.",
+      kind: "physics",
+      category: "feedback",
+      status: "planned",
+      token: "--velin-ease-elastic",
+      compatibility: { cssOnly: true, runtime: false, webComponents: false, studio: true, production: true, review: true, cli: true }
+    }
+  ],
+  composers: [
+    {
+      id: "sequence",
+      title: "Sequence Composer",
+      description: "Ordered fade/wait/slide composition API.",
+      kind: "composer",
+      category: "page",
+      status: "planned",
+      compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true }
+    }
+  ],
+  triggers: [
+    { id: "load", title: "Load", description: "Start when document/module initializes.", kind: "trigger", category: "page", status: "stable", compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "visible", title: "Visible", description: "Start when element enters the viewport (IntersectionObserver).", kind: "trigger", category: "page", status: "stable", compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "hidden", title: "Hidden", description: "Fire when element leaves the viewport. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "page", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "hover", title: "Hover", description: "Pointer enter / hover.", kind: "trigger", category: "buttons", status: "stable", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "focus", title: "Focus", description: "Keyboard/pointer focus.", kind: "trigger", category: "forms", status: "stable", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "click", title: "Click", description: "Pointer activation.", kind: "trigger", category: "buttons", status: "stable", compatibility: { cssOnly: false, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "scroll", title: "Scroll", description: "Scroll-linked or scroll-progress trigger.", kind: "trigger", category: "page", status: "stable", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "idle", title: "Idle", description: "After user idle timeout. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "feedback", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "media", title: "Media", description: "Match media query condition. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "page", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "container", title: "Container", description: "Container query / size trigger. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "cards", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "theme", title: "Theme", description: "Theme change trigger. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "page", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "custom", title: "Custom", description: "Custom event name via velin-trigger-event. (Planned \u2014 runtime falls back to visible.)", kind: "trigger", category: "page", status: "planned", compatibility: { cssOnly: false, runtime: false, webComponents: true, studio: true, production: true, review: true, cli: true } }
+  ],
+  policies: [
+    { id: "safe", title: "Safe", description: "Default layout-safe motion with capped durations.", kind: "policy", category: "page", status: "stable", maxDurationMs: 800, allowInfinite: false, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "reduced", title: "Reduced", description: "Honors prefers-reduced-motion first; shorten or skip decorative motion.", kind: "policy", category: "page", status: "stable", maxDurationMs: 200, forceReduced: true, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "marketing", title: "Marketing", description: "Expressive hero motion allowed within caps.", kind: "policy", category: "hero", status: "stable", maxDurationMs: 1200, allowInfinite: false, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "minimal", title: "Minimal", description: "Very little motion; feedback only.", kind: "policy", category: "page", status: "stable", maxDurationMs: 300, allowInfinite: false, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "accessibility", title: "Accessibility", description: "Strict reduced-motion + focus-safe interactions.", kind: "policy", category: "page", status: "stable", maxDurationMs: 200, forceReduced: true, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "performance", title: "Performance", description: "FPS-friendly; ban infinite decorative loops.", kind: "policy", category: "page", status: "stable", maxDurationMs: 600, allowInfinite: false, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "disabled", title: "Disabled", description: "All motion off.", kind: "policy", category: "page", status: "stable", disabled: true, compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } }
+  ],
+  blueprints: [
+    { id: "landing", title: "Landing", description: "Hero reveal + staggered sections + CTA hover.", kind: "blueprint", category: "hero", status: "beta", presets: ["heroReveal", "fade", "lift"], timeline: "hero-intro", policy: "marketing", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "dashboard", title: "Dashboard", description: "Minimal card stagger for admin shells.", kind: "blueprint", category: "cards", status: "beta", presets: ["fade", "slide"], timeline: "card-stagger", policy: "minimal", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "pricing", title: "Pricing", description: "Pricing cards with stagger and lift.", kind: "blueprint", category: "cards", status: "beta", presets: ["slide", "lift"], policy: "marketing", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "portfolio", title: "Portfolio", description: "Media zoom + parallax-safe reveals.", kind: "blueprint", category: "media", status: "beta", presets: ["zoom", "fade"], policy: "marketing", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "shop", title: "Shop", description: "Product cards and feedback pulses.", kind: "blueprint", category: "cards", status: "planned", presets: ["fade", "lift"], policy: "safe", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "forum", title: "Forum", description: "List slides and form feedback.", kind: "blueprint", category: "lists", status: "planned", presets: ["slide", "shake"], policy: "safe", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "docs", title: "Docs", description: "Minimal fade for documentation pages.", kind: "blueprint", category: "page", status: "beta", presets: ["fade"], policy: "minimal", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "blog", title: "Blog", description: "Article hero fade and card slides.", kind: "blueprint", category: "hero", status: "planned", presets: ["fade", "slide"], policy: "safe", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "crm", title: "CRM", description: "Table-safe minimal motion.", kind: "blueprint", category: "tables", status: "planned", presets: ["fade"], policy: "performance", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } },
+    { id: "login", title: "Login", description: "Form feedback and focus-safe motion.", kind: "blueprint", category: "forms", status: "beta", presets: ["fade", "shake"], policy: "accessibility", compatibility: { cssOnly: true, runtime: true, webComponents: true, studio: true, production: true, review: true, cli: true } }
+  ]
+};
+
+// core/motion/registry.js
+var cached = registry_default;
+function loadMotionRegistry(override = null) {
+  if (override) {
+    cached = override;
+    return cached;
+  }
+  return cached || registry_default;
+}
+function listMotion(namespace, filter = {}) {
+  const reg = loadMotionRegistry();
+  const key = namespace.endsWith("s") ? namespace : `${namespace}s`;
+  const items = reg[key] || reg[namespace] || [];
+  return items.filter((item) => {
+    if (filter.status && item.status !== filter.status) return false;
+    if (filter.category && item.category !== filter.category) return false;
+    if (filter.tag && !(item.tags || []).includes(filter.tag)) return false;
+    return true;
+  });
+}
+function getMotion(namespace, id) {
+  return listMotion(namespace).find((item) => item.id === id) || null;
+}
+function getPreset(id) {
+  return getMotion("presets", id);
+}
+function getPolicy(id) {
+  return getMotion("policies", id);
+}
+function getTrigger(id) {
+  return getMotion("triggers", id);
+}
+function getTimeline(id) {
+  return getMotion("timelines", id);
+}
+function resolvePresetId(id) {
+  if (!id) return null;
+  const direct = getPreset(id);
+  if (direct) return direct;
+  const aliases = {
+    scale: "zoom",
+    "hover-lift": "lift",
+    reveal: "fade"
+  };
+  const mapped = aliases[id];
+  return mapped ? getPreset(mapped) : null;
+}
+
+// core/motion/triggers.js
+var TRIGGER_V1 = ["load", "visible", "hover", "focus", "click", "scroll"];
+var TRIGGER_V2 = ["hidden", "idle", "media", "container", "theme", "custom"];
+var ALL_TRIGGERS = [...TRIGGER_V1, ...TRIGGER_V2];
+function readTrigger(el, fallback = "visible") {
+  const raw = (el.getAttribute("velin-trigger") || fallback || "visible").trim().toLowerCase();
+  return raw || fallback;
+}
+function bindTrigger(el, triggerId, onFire, opts = {}) {
+  const once = opts.once !== false;
+  const reduced = opts.reduced ?? prefersReducedMotion();
+  const id = (triggerId || "visible").toLowerCase();
+  const meta = getTrigger(id);
+  if (reduced || el.dataset.velinMotion === "off") {
+    onFire();
+    return () => {
+    };
+  }
+  if (meta?.status === "planned" && !TRIGGER_V1.includes(id)) {
+    return bindTrigger(el, "visible", onFire, opts);
+  }
+  let fired = false;
+  const fire = () => {
+    if (once && fired) return;
+    fired = true;
+    onFire();
+  };
+  if (id === "load") {
+    fire();
+    return () => {
+    };
+  }
+  if (id === "visible" || id === "scroll") {
+    return observeInView(el, () => fire());
+  }
+  if (id === "hover") {
+    const enter = () => fire();
+    el.addEventListener("pointerenter", enter);
+    return () => el.removeEventListener("pointerenter", enter);
+  }
+  if (id === "focus") {
+    const onFocus = () => fire();
+    el.addEventListener("focusin", onFocus);
+    return () => el.removeEventListener("focusin", onFocus);
+  }
+  if (id === "click") {
+    const onClick = () => fire();
+    el.addEventListener("click", onClick);
+    return () => el.removeEventListener("click", onClick);
+  }
+  if (id === "hidden") {
+    const stop = observeInView(el, () => {
+    });
+    if (typeof IntersectionObserver === "undefined") return () => {
+    };
+    const io = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) fire();
+      }
+    }, { threshold: 0 });
+    io.observe(el);
+    return () => {
+      stop();
+      io.disconnect();
+    };
+  }
+  if (id === "idle") {
+    const ms = Number(el.getAttribute("velin-trigger-delay") || 3e3);
+    const t = setTimeout(fire, ms);
+    return () => clearTimeout(t);
+  }
+  if (id === "media") {
+    const q = el.getAttribute("velin-trigger-media") || "(min-width: 768px)";
+    if (typeof window === "undefined" || !window.matchMedia) {
+      fire();
+      return () => {
+      };
+    }
+    const mql = window.matchMedia(q);
+    const handler = () => {
+      if (mql.matches) fire();
+    };
+    handler();
+    mql.addEventListener?.("change", handler);
+    return () => mql.removeEventListener?.("change", handler);
+  }
+  if (id === "theme") {
+    const root = el.ownerDocument?.documentElement;
+    if (!root || typeof MutationObserver === "undefined") {
+      fire();
+      return () => {
+      };
+    }
+    const mo = new MutationObserver(() => fire());
+    mo.observe(root, { attributes: true, attributeFilter: ["data-velin-theme", "class"] });
+    return () => mo.disconnect();
+  }
+  if (id === "custom") {
+    const evt = el.getAttribute("velin-trigger-event") || "velin:motion";
+    const handler = () => fire();
+    el.addEventListener(evt, handler);
+    return () => el.removeEventListener(evt, handler);
+  }
+  if (id === "container") {
+    return observeInView(el, () => fire());
+  }
+  return observeInView(el, () => fire());
+}
+function armMotionElement(el, applyPreset) {
+  applyPreset();
+  const trigger = readTrigger(el, el.hasAttribute("velin-hover") ? "hover" : "visible");
+  if (prefersReducedMotion() || el.dataset.velinMotion === "off") {
+    markVisible(el);
+    return () => {
+    };
+  }
+  if (trigger === "hover" || trigger === "focus") {
+    markVisible(el);
+    return () => {
+    };
+  }
+  if (trigger === "load") {
+    markVisible(el);
+    return () => {
+    };
+  }
+  return bindTrigger(el, trigger, () => markVisible(el));
+}
+
+// core/motion/policy.js
+function resolvePolicy(id = "safe") {
+  return getPolicy(id) || getPolicy("safe");
+}
+function shouldDisableMotion(policy) {
+  if (!policy) return prefersReducedMotion();
+  if (policy.disabled) return true;
+  if (policy.forceReduced && prefersReducedMotion()) return true;
+  if (prefersReducedMotion() && policy.id !== "marketing") return true;
+  return false;
+}
+function capDuration(ms, policy) {
+  const max = policy?.maxDurationMs ?? 800;
+  if (policy?.disabled) return 0;
+  return Math.min(Number(ms) || 0, max);
+}
+function applyMotionVars(el, policy) {
+  const duration = el.getAttribute("velin-duration");
+  const delay = el.getAttribute("velin-delay");
+  const ease = el.getAttribute("velin-ease");
+  if (duration) {
+    const capped = capDuration(Number(duration), policy);
+    el.style.setProperty("--velin-motion-duration", `${capped}ms`);
+    el.style.animationDuration = `${capped}ms`;
+  }
+  if (delay) el.style.animationDelay = `${Number(delay)}ms`;
+  if (ease) {
+    const map = {
+      spring: "var(--velin-ease-spring)",
+      bounce: "var(--velin-ease-bounce)",
+      elastic: "var(--velin-ease-elastic)",
+      default: "var(--velin-ease-default)"
+    };
+    el.style.animationTimingFunction = map[ease] || ease;
+  }
+  if (policy?.disabled || shouldDisableMotion(policy)) {
+    el.dataset.velinMotion = "off";
+  }
+}
+
+// core/motion/timeline.js
+function runTimeline(timelineId, root, opts = {}) {
+  const tl = getTimeline(timelineId);
+  if (!tl) return { ok: false, error: `Unknown timeline "${timelineId}"`, ran: [] };
+  const stepMs = opts.stepMs ?? 120;
+  const ran = [];
+  if (opts.policyDisabled || prefersReducedMotion()) {
+    for (const step of tl.steps || []) {
+      const el = resolveStep(root, step);
+      if (el) markVisible(el);
+      ran.push(step);
+    }
+    return { ok: true, ran };
+  }
+  let delay = 0;
+  for (const step of tl.steps || []) {
+    const el = resolveStep(root, step);
+    if (!el) continue;
+    const d = delay;
+    delay += stepMs;
+    if (typeof window !== "undefined" && window.setTimeout) {
+      window.setTimeout(() => markVisible(el), d);
+    } else {
+      markVisible(el);
+    }
+    ran.push(step);
+  }
+  return { ok: true, ran, timeline: tl };
+}
+function resolveStep(root, step) {
+  if (!root?.querySelector) return null;
+  return root.querySelector(`[data-velin-step="${step}"]`) || root.querySelector(`[velin-step="${step}"]`) || root.querySelector(`#${CSS.escape?.(step) || step}`);
+}
+function enhanceTimelines(root) {
+  if (!root?.querySelectorAll) return () => {
+  };
+  const nodes = root.querySelectorAll("[velin-timeline]");
+  const teardowns = [];
+  for (const el of nodes) {
+    const id = el.getAttribute("velin-timeline");
+    const result = runTimeline(id, el);
+    teardowns.push(() => result);
+  }
+  return () => {
+  };
+}
+
+// core/motion/composer.js
+function enhanceSequences(root) {
+  if (!root?.querySelectorAll) return () => {
+  };
+  const nodes = [...root.querySelectorAll("[velin-motion-sequence]")];
+  for (const section of nodes) {
+    const children = [...section.children];
+    let i = 0;
+    const stepMs = Number(section.getAttribute("velin-sequence-gap") || 120);
+    for (const child of children) {
+      child.classList.add("velin-animate-on-scroll", "velin-animate-on-scroll--fade");
+      if (prefersReducedMotion()) {
+        markVisible(child);
+      } else if (typeof setTimeout !== "undefined") {
+        const delayMs = i * stepMs;
+        setTimeout(() => markVisible(child), delayMs);
+      } else {
+        markVisible(child);
+      }
+      i += 1;
+    }
+  }
+  return () => {
+  };
+}
+
+// core/motion/index.js
+var LEGACY_ATTRS = ["velin-reveal", "velin-fade", "velin-slide", "velin-scale", "velin-parallax", "velin-hover"];
+var teardownFns = [];
+function initMotion(options = {}) {
+  const root = options.root || (typeof document !== "undefined" ? document : null);
+  if (!root) return () => {
+  };
+  const policy = resolvePolicy(
+    options.policy || root.documentElement?.getAttribute?.("data-velin-motion-policy") || root.querySelector?.("[data-velin-motion-policy]")?.getAttribute("data-velin-motion-policy") || "safe"
+  );
+  const selector = options.selector || [
+    "[velin-motion]",
+    "[velin-reveal]",
+    "[velin-fade]",
+    "[velin-slide]",
+    "[velin-scale]",
+    "[velin-parallax]",
+    "[velin-hover]",
+    ".velin-animate-on-scroll"
+  ].join(",");
+  const elements = root.querySelectorAll(selector);
+  const reduced = shouldDisableMotion(policy) || prefersReducedMotion();
+  for (const el of elements) {
+    if (el.dataset.velinMotionInit) continue;
+    el.dataset.velinMotionInit = "1";
+    applyMotionVars(el, policy);
+    const attrs = {};
+    const motionPreset = el.getAttribute("velin-motion");
+    if (motionPreset) {
+      attrs.motion = motionPreset;
+      const resolved = resolvePresetId(motionPreset);
+      if (resolved?.id) attrs[resolved.id] = "true";
+    }
+    for (const name of LEGACY_ATTRS) {
+      if (el.hasAttribute(name)) attrs[name.replace("velin-", "")] = el.getAttribute(name) || "true";
+    }
+    applyEffects(el, attrs);
+    if (reduced || el.dataset.velinMotion === "off") {
+      markVisible(el);
+      continue;
+    }
+    const stop = armMotionElement(el, () => applyEffects(el, attrs));
+    teardownFns.push(stop);
+  }
+  enhanceStagger(root);
+  bindSmoothScroll(root);
+  enhanceTimelines(root);
+  enhanceSequences(root);
+  return () => {
+    teardownFns.forEach((fn) => {
+      try {
+        fn();
+      } catch {
+      }
+    });
+    teardownFns = [];
+    disconnectInViewObserver();
+  };
+}
+
+// core/attributes/registry.js
+var registry = /* @__PURE__ */ new Map();
+function registerAttribute(name, handler) {
+  registry.set(name, handler);
+}
+function getAttributeHandler(name) {
+  return registry.get(name);
+}
+function bridgeComponent(el, tag, attrs = {}) {
+  el.setAttribute("data-velin-component", tag);
+  for (const [k, v] of Object.entries(attrs)) {
+    if (v != null) el.setAttribute(k, v);
+  }
+  return lazyDefine(tag);
+}
+function registerBuiltins() {
+  registerAttribute("velin-modal", {
+    enhance(el) {
+      bridgeComponent(el, "velin-modal", { open: el.getAttribute("velin-modal") || "" });
+    }
+  });
+  registerAttribute("velin-tabs", { enhance: (el) => bridgeComponent(el, "velin-tabs") });
+  registerAttribute("velin-accordion", { enhance: (el) => bridgeComponent(el, "velin-accordion") });
+  registerAttribute("velin-tooltip", {
+    enhance(el) {
+      const tip = el.getAttribute("velin-tooltip") || el.getAttribute("title") || "";
+      if (tip && el.hasAttribute("title")) el.removeAttribute("title");
+      if (el.tagName === "VELIN-TOOLTIP" || el.tagName === "VELIN-TOOLTIP-WC") {
+        el.setAttribute("content", tip);
+        return lazyDefine("velin-tooltip");
+      }
+      const wc = document.createElement("velin-tooltip");
+      wc.setAttribute("content", tip);
+      const parent = el.parentElement;
+      if (parent) {
+        parent.insertBefore(wc, el);
+        wc.appendChild(el);
+      }
+      return lazyDefine("velin-tooltip");
+    }
+  });
+  registerAttribute("velin-copy", {
+    enhance(el) {
+      const text = el.getAttribute("velin-copy") || el.textContent?.trim() || "";
+      if (!el.querySelector("velin-copy")) {
+        const wc = document.createElement("velin-copy");
+        wc.setAttribute("value", text);
+        if (el.tagName === "BUTTON") {
+          wc.append(...el.childNodes);
+          el.replaceWith(wc);
+          return lazyDefine("velin-copy");
+        }
+        el.appendChild(wc);
+      }
+      return lazyDefine("velin-copy");
+    }
+  });
+  registerAttribute("velin-counter", {
+    enhance(el) {
+      bridgeComponent(el, "velin-counter", {
+        value: el.getAttribute("velin-counter") || "0"
+      });
+    }
+  });
+  registerAttribute("velin-notify", {
+    async enhance(el) {
+      await lazyDefine("velin-toast");
+      el.addEventListener("click", () => {
+        const msg = el.getAttribute("velin-notify") || el.textContent || "";
+        document.dispatchEvent(
+          new CustomEvent("velin-toast-show", { detail: { message: msg, variant: el.dataset.variant || "info" } })
+        );
+      });
+    }
+  });
+  registerAttribute("velin-theme", {
+    enhance(el) {
+      const theme = el.getAttribute("velin-theme") || "toggle";
+      if (theme === "toggle") {
+        if (!el.querySelector("velin-theme-toggle")) {
+          el.appendChild(document.createElement("velin-theme-toggle"));
+        }
+        return lazyDefine("velin-theme-toggle");
+      }
+      document.documentElement.setAttribute("data-velin-theme", theme);
+    }
+  });
+  registerAttribute("velin-scroll-top", {
+    enhance(el) {
+      const raw = el.getAttribute("velin-scroll-top");
+      const threshold = raw && raw !== "true" ? raw : "300";
+      if (el.tagName === "VELIN-SCROLL-TOP") {
+        if (raw && raw !== "true") el.setAttribute("threshold", threshold);
+        return lazyDefine("velin-scroll-top");
+      }
+      let wc = document.querySelector("velin-scroll-top");
+      if (!wc) {
+        wc = document.createElement("velin-scroll-top");
+        wc.setAttribute("threshold", threshold);
+        (el === document.body || el === document.documentElement ? document.body : el).appendChild(wc);
+      }
+      return lazyDefine("velin-scroll-top");
+    }
+  });
+  registerAttribute("velin-progress", {
+    enhance(el) {
+      const ring = el.hasAttribute("ring");
+      if (ring) return bridgeComponent(el, "velin-progress-ring");
+      el.classList.add("velin-progress");
+      const val = parseInt(el.getAttribute("velin-progress") || "0", 10);
+      el.setAttribute("role", "progressbar");
+      el.setAttribute("aria-valuenow", String(val));
+      el.style.setProperty("--velin-progress", `${Math.min(100, val)}%`);
+    }
+  });
+  registerAttribute("velin-search", {
+    async enhance(el) {
+      if (el.tagName !== "VELIN-SEARCH") {
+        const host = document.createElement("velin-search");
+        host.setAttribute("index", el.getAttribute("data-search-index") || "/search-index.json");
+        el.replaceWith(host);
+        host.appendChild(el);
+      }
+      return lazyDefine("velin-search");
+    }
+  });
+  registerAttribute("velin-lazy", {
+    enhance(el) {
+      if (el.tagName === "IMG") {
+        el.loading = "lazy";
+        el.decoding = "async";
+        if (el.hasAttribute("velin-skeleton") || el.dataset.velinSkeleton) {
+          el.classList.add("velin-skeleton", "velin-skeleton--image");
+          el.addEventListener("load", () => el.classList.remove("velin-skeleton", "velin-skeleton--image"), { once: true });
+        }
+      }
+    }
+  });
+  registerAttribute("velin-skeleton", {
+    enhance(el) {
+      const variant = el.getAttribute("velin-skeleton") || "text";
+      el.classList.add("velin-skeleton", `velin-skeleton--${variant}`);
+      const hasText = Boolean(el.textContent?.trim()) && el.children.length > 0;
+      if (!hasText && !el.textContent?.trim()) {
+        el.setAttribute("aria-hidden", "true");
+      }
+    }
+  });
+  registerAttribute("velin-loading", {
+    enhance(el) {
+      el.classList.add("velin-spinner");
+      el.setAttribute("aria-busy", "true");
+      el.setAttribute("role", "status");
+      if (!el.getAttribute("aria-label")?.trim()) {
+        el.setAttribute("aria-label", "Loading");
+      }
+    }
+  });
+  registerAttribute("velin-grid", {
+    enhance(el) {
+      const cols = el.getAttribute("velin-grid") || "auto";
+      el.classList.add("velin-grid");
+      if (cols !== "auto") el.style.setProperty("--velin-grid-cols", cols);
+    }
+  });
+  registerAttribute("velin-anchor", {
+    enhance(el) {
+      if (!el.id && el.getAttribute("velin-anchor")) el.id = el.getAttribute("velin-anchor");
+      el.setAttribute("tabindex", "-1");
+    }
+  });
+  registerAttribute("velin-code", {
+    async enhance(el) {
+      const lang = el.getAttribute("velin-code") || el.getAttribute("language") || el.getAttribute("data-language") || "";
+      el.classList.add("velin-code-block");
+      if (lang && lang !== "true") {
+        el.dataset.language = lang;
+        if (!el.getAttribute("language")) el.setAttribute("language", lang);
+      }
+      if (!el.querySelector("[data-velin-copy]")) {
+        const btn = document.createElement("button");
+        btn.type = "button";
+        btn.className = "velin-code-block__copy velin-btn velin-btn--sm";
+        btn.textContent = "Copy";
+        btn.setAttribute("data-velin-copy", "");
+        btn.setAttribute("velin-copy", el.querySelector("code")?.textContent || el.textContent || "");
+        el.style.position = "relative";
+        el.appendChild(btn);
+      }
+      await lazyDefine("velin-copy");
+      const { initHighlight, highlightElement } = await import("./highlight-M2ELQNYK.js");
+      const immediate = el.getAttribute("data-velin-highlight") === "immediate" || typeof matchMedia !== "undefined" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+      if (immediate) {
+        await highlightElement(el);
+      } else {
+        initHighlight(el, { root: el });
+      }
+    }
+  });
+  registerAttribute("velin-quote", {
+    enhance(el) {
+      if (el.tagName === "BLOCKQUOTE" || el.tagName === "Q") {
+        el.classList.add("velin-quote");
+      }
+    }
+  });
+  registerAttribute("velin-highlight", {
+    enhance(el) {
+      el.classList.add("velin-highlight");
+    }
+  });
+  registerAttribute("velin-transparency", {
+    async enhance(el) {
+      const { attach } = await import("./attach-H2ZSEAE6.js");
+      attach(el);
+    }
+  });
+  registerAttribute("velin-disclosure", {
+    async enhance(el) {
+      const { attach } = await import("./attach-H2ZSEAE6.js");
+      if (!el.hasAttribute("velin-transparency")) el.setAttribute("velin-transparency", "");
+      attach(el);
+    }
+  });
+  for (const motion of ["velin-motion", "velin-trigger", "velin-duration", "velin-delay", "velin-ease", "velin-timeline", "velin-motion-sequence", "velin-reveal", "velin-fade", "velin-slide", "velin-scale", "velin-parallax", "velin-hover", "velin-stagger", "velin-scroll"]) {
+    registerAttribute(motion, { enhance() {
+    } });
+  }
+}
+registerBuiltins();
+var enhanced = /* @__PURE__ */ new WeakSet();
+async function bootAttributes(root = document) {
+  const selector = [...registry.keys()].map((a) => `[${a}]`).join(",");
+  const elements = root.querySelectorAll(selector);
+  for (const el of elements) {
+    if (enhanced.has(el)) continue;
+    for (const attr of registry.keys()) {
+      if (!el.hasAttribute(attr)) continue;
+      const handler = registry.get(attr);
+      if (handler?.enhance) await handler.enhance(el);
+    }
+    enhanced.add(el);
+  }
+  initMotion({ root });
+  if (typeof HTMLElement !== "undefined") {
+    const { bindDeclarativeSearch } = await import("./velin-search-L3UG6NDQ.js");
+    bindDeclarativeSearch(root);
+    if (!document.querySelector("velin-announcer")) {
+      const { getAnnouncer } = await import("./a11y-utils-IRC7LOPF.js");
+      getAnnouncer();
+    }
+  }
+}
+function listRegisteredAttributes() {
+  return [...registry.keys()];
+}
+export {
+  bootAttributes,
+  getAttributeHandler,
+  listRegisteredAttributes,
+  registerAttribute
+};