@birdapi/velinstyle 0.7.0 → 0.9.0

package/dist/chunks/chunk-F7OLHTGX.js

@@ -0,0 +1,22 @@
+// components/shadow-a11y-styles.js
+var SHADOW_A11Y_STYLES = `
+  :host { display: block; }
+  button, [role="button"] {
+    min-inline-size: 2.75rem;
+    min-block-size: 2.75rem;
+    cursor: pointer;
+  }
+  button:focus-visible, [role="button"]:focus-visible {
+    outline: 3px solid var(--velin-color-focus, #2563eb);
+    outline-offset: 2px;
+  }
+  @media (forced-colors: active) {
+    button, [role="button"] {
+      border: 1px solid ButtonText;
+    }
+  }
+`;
+
+export {
+  SHADOW_A11Y_STYLES
+};

package/dist/chunks/chunk-J472ERN2.js

@@ -0,0 +1,242 @@
+import {
+  observeInView
+} from "./chunk-7MCGPHVC.js";
+import {
+  lexJs
+} from "./chunk-M5CHQVP6.js";
+
+// core/highlight/registry.js
+var languages = /* @__PURE__ */ new Map();
+var loading = /* @__PURE__ */ new Map();
+var LAZY_LOADERS = {
+  js: () => import("./js-MNSNYTJU.js"),
+  javascript: () => import("./js-MNSNYTJU.js"),
+  ts: () => import("./typescript-JT3CCYWL.js"),
+  typescript: () => import("./typescript-JT3CCYWL.js"),
+  html: () => import("./html-ZODC4DLQ.js"),
+  xml: () => import("./html-ZODC4DLQ.js"),
+  css: () => import("./css-MQ5YU77P.js"),
+  json: () => import("./json-VEM2HFH3.js"),
+  md: () => import("./markdown-E7OPGS3S.js"),
+  markdown: () => import("./markdown-E7OPGS3S.js"),
+  shell: () => import("./shell-QTRK4U4E.js"),
+  bash: () => import("./shell-QTRK4U4E.js"),
+  sh: () => import("./shell-QTRK4U4E.js"),
+  sql: () => import("./sql-PPWLHGJ2.js"),
+  text: () => import("./plain-LJJDC5TN.js"),
+  plain: () => import("./plain-LJJDC5TN.js"),
+  txt: () => import("./plain-LJJDC5TN.js"),
+  markup: () => import("./html-ZODC4DLQ.js"),
+  console: () => import("./plain-LJJDC5TN.js"),
+  php: () => import("./php-MLL7T3LT.js"),
+  blade: () => import("./blade-LIQLVKZQ.js")
+};
+function normalizeLanguage(name) {
+  const n = (name || "").trim().toLowerCase();
+  if (!n) return "";
+  if (n.startsWith("language-")) return normalizeLanguage(n.slice(9));
+  const map = {
+    javascript: "js",
+    jsx: "js",
+    typescript: "ts",
+    tsx: "ts",
+    markup: "html",
+    xml: "html",
+    svg: "html",
+    bash: "shell",
+    sh: "shell",
+    zsh: "shell",
+    md: "markdown",
+    plaintext: "text",
+    "plain-text": "text",
+    yml: "text",
+    yaml: "text",
+    toml: "text",
+    ini: "text",
+    php8: "php"
+  };
+  return map[n] || n;
+}
+function registerLanguage(name, lexerFn) {
+  languages.set(normalizeLanguage(name), lexerFn);
+}
+function getLanguage(name) {
+  return languages.get(normalizeLanguage(name));
+}
+async function lazyLoadLanguage(name) {
+  const key = normalizeLanguage(name);
+  if (!key) return void 0;
+  if (languages.has(key)) return languages.get(key);
+  if (loading.has(key)) return loading.get(key);
+  const loader = LAZY_LOADERS[key];
+  if (!loader) return void 0;
+  const p = loader().then((mod) => {
+    const fn = mod.default;
+    languages.set(key, fn);
+    loading.delete(key);
+    return fn;
+  });
+  loading.set(key, p);
+  return p;
+}
+function listLanguages() {
+  return [.../* @__PURE__ */ new Set([...languages.keys(), ...Object.keys(LAZY_LOADERS)])];
+}
+registerLanguage("js", lexJs);
+
+// core/highlight/render.js
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+function escapeHtml(s) {
+  return s.replace(/[&<>"]/g, (c) => ESC[c] || c);
+}
+function renderTokens(tokens) {
+  return tokens.map((t) => {
+    const type = t.type === "plain" ? "" : t.type;
+    const cls = type ? `velin-token velin-token--${type}` : "velin-token";
+    return `<span class="${cls}">${escapeHtml(t.value)}</span>`;
+  }).join("");
+}
+function applyHighlight(codeEl, tokens) {
+  codeEl.innerHTML = renderTokens(tokens);
+  codeEl.classList.add("velin-syntax-ready");
+  codeEl.closest("pre")?.classList.add("velin-syntax-ready");
+  codeEl.closest(".velin-code-block")?.classList.add("velin-syntax-ready");
+}
+
+// core/highlight/highlight.js
+function resolveLanguage(el) {
+  const pre = el.tagName === "PRE" ? el : el.closest("pre");
+  const code = el.tagName === "CODE" ? el : pre?.querySelector("code") || el;
+  const host = pre || code;
+  const fromAttr = host.getAttribute("language") || host.getAttribute("data-language") || host.getAttribute("velin-code") || "";
+  if (fromAttr && fromAttr !== "true") return normalizeLanguage(fromAttr);
+  const cls = code?.className || "";
+  const langMatch = cls.match(/\blanguage-([\w-]+)\b/i);
+  if (langMatch) return normalizeLanguage(langMatch[1]);
+  return "";
+}
+function getSourceText(el) {
+  const code = el.tagName === "CODE" ? el : el.querySelector("code");
+  const target = code || el;
+  if (target.dataset.velinSource != null) return target.dataset.velinSource;
+  const html = target.innerHTML;
+  if (html && /&lt;|&gt;|&amp;/.test(html)) {
+    const ta = document.createElement("textarea");
+    ta.innerHTML = html.replace(/<br\s*\/?>/gi, "\n");
+    if (ta.value) return ta.value;
+  }
+  return target.textContent || "";
+}
+async function highlightElement(el, options = {}) {
+  if (el.dataset.velinHighlighted === "1") return;
+  const pre = el.tagName === "PRE" ? el : el.closest("pre") || el;
+  const codeEl = el.tagName === "CODE" ? el : pre.querySelector("code") || document.createElement("code");
+  if (!pre.querySelector("code") && codeEl !== el) {
+    const text = getSourceText(pre);
+    codeEl.textContent = text;
+    pre.textContent = "";
+    pre.appendChild(codeEl);
+  }
+  if (!codeEl.dataset.velinSource) {
+    codeEl.dataset.velinSource = codeEl.textContent || "";
+  }
+  const lang = options.language || resolveLanguage(pre);
+  if (!lang) return;
+  pre.classList.add("velin-syntax-pending");
+  codeEl.classList.add("velin-syntax-pending");
+  let lexer = options.lexer || getLanguage(lang);
+  if (!lexer) lexer = await lazyLoadLanguage(lang);
+  if (!lexer) {
+    lexer = getLanguage("text") || await lazyLoadLanguage("text");
+  }
+  const source = codeEl.dataset.velinSource || getSourceText(codeEl) || "";
+  if (!lexer) {
+    codeEl.textContent = source;
+    pre.classList.remove("velin-syntax-pending");
+    codeEl.classList.remove("velin-syntax-pending");
+    pre.classList.add("velin-syntax-ready");
+    codeEl.classList.add("velin-syntax-ready");
+    return;
+  }
+  try {
+    const tokens = lexer(source);
+    applyHighlight(codeEl, tokens);
+    codeEl.dataset.velinHighlighted = "1";
+    pre.dataset.velinHighlighted = "1";
+  } catch (err) {
+    console.warn("[velin-highlight]", lang, err);
+    codeEl.textContent = source;
+  }
+  pre.classList.remove("velin-syntax-pending");
+  codeEl.classList.remove("velin-syntax-pending");
+  pre.classList.add("velin-syntax-ready");
+  codeEl.classList.add("velin-syntax-ready");
+}
+async function highlightAll(root = document) {
+  const blocks = root.querySelectorAll(
+    'pre[velin-code], pre[data-language], pre code[class*="language-"], [velin-code-block] pre, .velin-doc-example__code pre'
+  );
+  await Promise.all([...blocks].map((el) => highlightElement(el)));
+}
+
+// core/highlight/observe.js
+function initHighlight(root = document, options = {}) {
+  if (typeof document === "undefined") return () => {
+  };
+  const selector = options.selector || [
+    "pre[velin-code]",
+    "pre[language]",
+    "pre[data-language]",
+    'pre code[class*="language-"]',
+    "velin-code-block pre",
+    ".velin-doc-example__code pre"
+  ].join(",");
+  const nodes = root.querySelectorAll(selector);
+  const teardowns = [];
+  const reduced = typeof matchMedia !== "undefined" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+  for (const node of nodes) {
+    const pre = node.tagName === "PRE" ? node : node.closest("pre");
+    if (!pre || pre.dataset.velinObserve === "1") continue;
+    pre.dataset.velinObserve = "1";
+    if (reduced || options.immediate) {
+      void highlightElement(pre);
+      continue;
+    }
+    pre.classList.add("velin-syntax-pending");
+    const stop = observeInView(pre, async (el) => {
+      await highlightElement(el);
+    });
+    teardowns.push(stop);
+  }
+  return () => teardowns.forEach((fn) => fn());
+}
+var observeCodeBlocks = initHighlight;
+
+// core/highlight/index.js
+var velinSyntax = {
+  highlightElement,
+  highlightAll,
+  initHighlight,
+  observeCodeBlocks,
+  registerLanguage,
+  lazyLoadLanguage,
+  listLanguages
+};
+
+export {
+  normalizeLanguage,
+  registerLanguage,
+  getLanguage,
+  lazyLoadLanguage,
+  listLanguages,
+  escapeHtml,
+  renderTokens,
+  applyHighlight,
+  resolveLanguage,
+  getSourceText,
+  highlightElement,
+  highlightAll,
+  initHighlight,
+  observeCodeBlocks,
+  velinSyntax
+};

package/dist/chunks/chunk-LA7264K4.js

@@ -0,0 +1,85 @@
+// components/sanitize.js
+var ESCAPE_MAP = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var ESCAPE_RE = /[&<>"']/g;
+var CONTROL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+var ALLOWED_URL_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "data:", "mailto:", "tel:"]);
+var BLOCKED_DATA_MIME = /^data:(?:text\/html|image\/svg\+xml|application\/xml)/i;
+var ALLOWED_DATA_IMAGE = /^data:image\/(png|jpeg|jpg|gif|webp|avif);base64,/i;
+var SECURE_INPUT_TYPES = /* @__PURE__ */ new Set(["text", "password", "email", "search", "tel", "url", "number"]);
+function escapeHTML(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(ESCAPE_RE, (ch) => ESCAPE_MAP[ch]);
+}
+function stripControlChars(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(CONTROL_RE, "");
+}
+function escapeHTMLAttribute(str) {
+  return escapeHTML(stripControlChars(str));
+}
+function sanitizeURL(url, base) {
+  if (typeof url !== "string") return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  if (/^\s*javascript:/i.test(trimmed) || /^\s*vbscript:/i.test(trimmed)) return "";
+  if (BLOCKED_DATA_MIME.test(trimmed)) return "";
+  if (/^data:/i.test(trimmed) && !ALLOWED_DATA_IMAGE.test(trimmed)) return "";
+  try {
+    const parsed = new URL(trimmed, base || (typeof location !== "undefined" ? location.href : "https://example.invalid/"));
+    if (!ALLOWED_URL_PROTOCOLS.has(parsed.protocol)) return "";
+    if (parsed.protocol === "data:" && !ALLOWED_DATA_IMAGE.test(parsed.href)) return "";
+    return parsed.href;
+  } catch {
+    if (trimmed.startsWith("#") || trimmed.startsWith("/")) return trimmed;
+    return "";
+  }
+}
+function sanitizeSearchUrl(url, base) {
+  if (typeof url !== "string") return "#";
+  const trimmed = url.trim();
+  if (!trimmed) return "#";
+  if (trimmed.startsWith("#")) return trimmed;
+  if (trimmed.startsWith("/") && !trimmed.startsWith("//")) return trimmed;
+  const safe = sanitizeURL(trimmed, base);
+  return safe || "#";
+}
+function sanitizeInputType(type) {
+  const t = String(type || "text").toLowerCase();
+  return SECURE_INPUT_TYPES.has(t) ? t : "text";
+}
+var _purify = null;
+async function loadPurify() {
+  if (_purify) return _purify;
+  try {
+    const mod = await import("./browser-MRKYZPEH.js");
+    _purify = mod.default || mod;
+  } catch {
+    _purify = null;
+  }
+  return _purify;
+}
+var SVG_ALLOWED_TAGS = ["svg", "g", "path", "circle", "rect", "line", "polyline", "polygon", "ellipse", "defs", "use", "symbol", "title", "desc", "clipPath", "mask", "linearGradient", "radialGradient", "stop", "pattern", "text", "tspan"];
+var SVG_ALLOWED_ATTR = ["viewBox", "xmlns", "fill", "stroke", "stroke-width", "stroke-linecap", "stroke-linejoin", "d", "cx", "cy", "r", "rx", "ry", "x", "y", "width", "height", "x1", "y1", "x2", "y2", "points", "transform", "opacity", "class", "id", "href", "xlink:href", "aria-hidden", "role", "focusable", "clip-path", "mask", "offset", "stop-color", "stop-opacity", "gradientUnits", "gradientTransform", "spreadMethod", "fx", "fy", "patternUnits", "patternContentUnits", "preserveAspectRatio"];
+async function sanitizeSVG(svgMarkup) {
+  if (typeof svgMarkup !== "string") return "";
+  const DOMPurify = await loadPurify();
+  if (DOMPurify?.sanitize) {
+    return DOMPurify.sanitize(svgMarkup, {
+      USE_PROFILES: { svg: true, svgFilters: true },
+      ADD_TAGS: SVG_ALLOWED_TAGS,
+      ADD_ATTR: SVG_ALLOWED_ATTR,
+      FORBID_TAGS: ["script", "foreignObject", "iframe", "object", "embed"],
+      FORBID_ATTR: ["onload", "onerror", "onclick", "onmouseover"]
+    });
+  }
+  return svgMarkup.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/<foreignObject[\s\S]*?<\/foreignObject>/gi, "");
+}
+
+export {
+  escapeHTML,
+  escapeHTMLAttribute,
+  sanitizeURL,
+  sanitizeSearchUrl,
+  sanitizeInputType,
+  sanitizeSVG
+};

package/dist/chunks/chunk-M5CHQVP6.js

@@ -0,0 +1,61 @@
+import {
+  tokenizeWithKeywords
+} from "./chunk-7FFAMRFV.js";
+
+// core/highlight/languages/js.js
+var KEYWORDS = {
+  const: 1,
+  let: 1,
+  var: 1,
+  function: 1,
+  return: 1,
+  if: 1,
+  else: 1,
+  for: 1,
+  while: 1,
+  do: 1,
+  switch: 1,
+  case: 1,
+  break: 1,
+  continue: 1,
+  new: 1,
+  class: 1,
+  extends: 1,
+  import: 1,
+  export: 1,
+  from: 1,
+  default: 1,
+  async: 1,
+  await: 1,
+  try: 1,
+  catch: 1,
+  finally: 1,
+  throw: 1,
+  typeof: 1,
+  instanceof: 1,
+  in: 1,
+  of: 1,
+  true: 1,
+  false: 1,
+  null: 1,
+  undefined: 1,
+  void: 1,
+  this: 1
+};
+var BASE = [
+  { type: "comment", re: /\/\/[^\n]*/y },
+  { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+  { type: "string", re: /"(?:\\.|[^"\\])*"/y },
+  { type: "string", re: /'(?:\\.|[^'\\])*'/y },
+  { type: "string", re: /`(?:\\.|[^`\\])*`/y },
+  { type: "number", re: /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/y },
+  { type: "operator", re: /[+\-*/%=<>!&|^~?:]+/y },
+  { type: "punctuation", re: /[{}[\]();,.]/y }
+];
+function lexJs(code) {
+  return tokenizeWithKeywords(code, KEYWORDS, BASE);
+}
+
+export {
+  lexJs
+};

package/dist/chunks/chunk-MKZP2TBH.js

@@ -0,0 +1,89 @@
+// components/sanitize.js
+var ESCAPE_MAP = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var ESCAPE_RE = /[&<>"']/g;
+var CONTROL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+var ALLOWED_URL_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "data:", "mailto:", "tel:"]);
+var BLOCKED_DATA_MIME = /^data:(?:text\/html|image\/svg\+xml|application\/xml)/i;
+var ALLOWED_DATA_IMAGE = /^data:image\/(png|jpeg|jpg|gif|webp|avif);base64,/i;
+var SECURE_INPUT_TYPES = /* @__PURE__ */ new Set(["text", "password", "email", "search", "tel", "url", "number"]);
+function escapeHTML(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(ESCAPE_RE, (ch) => ESCAPE_MAP[ch]);
+}
+function stripControlChars(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(CONTROL_RE, "");
+}
+function escapeHTMLAttribute(str) {
+  return escapeHTML(stripControlChars(str));
+}
+function sanitizeURL(url, base) {
+  if (typeof url !== "string") return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  if (/^\s*javascript:/i.test(trimmed) || /^\s*vbscript:/i.test(trimmed)) return "";
+  if (BLOCKED_DATA_MIME.test(trimmed)) return "";
+  if (/^data:/i.test(trimmed) && !ALLOWED_DATA_IMAGE.test(trimmed)) return "";
+  try {
+    const parsed = new URL(trimmed, base || (typeof location !== "undefined" ? location.href : "https://example.invalid/"));
+    if (!ALLOWED_URL_PROTOCOLS.has(parsed.protocol)) return "";
+    if (parsed.protocol === "data:" && !ALLOWED_DATA_IMAGE.test(parsed.href)) return "";
+    return parsed.href;
+  } catch {
+    if (trimmed.startsWith("#") || trimmed.startsWith("/")) return trimmed;
+    return "";
+  }
+}
+function sanitizeSearchUrl(url, base) {
+  if (typeof url !== "string") return "#";
+  const trimmed = url.trim();
+  if (!trimmed) return "#";
+  if (trimmed.startsWith("#")) return trimmed;
+  if (trimmed.startsWith("/") && !trimmed.startsWith("//")) return trimmed;
+  if (!/^https?:\/\//i.test(trimmed)) {
+    if (/^\s*javascript:/i.test(trimmed) || /^\s*vbscript:/i.test(trimmed)) return "#";
+    return trimmed;
+  }
+  const safe = sanitizeURL(trimmed, base);
+  return safe || "#";
+}
+function sanitizeInputType(type) {
+  const t = String(type || "text").toLowerCase();
+  return SECURE_INPUT_TYPES.has(t) ? t : "text";
+}
+var _purify = null;
+async function loadPurify() {
+  if (_purify) return _purify;
+  try {
+    const mod = await import("./browser-MRKYZPEH.js");
+    _purify = mod.default || mod;
+  } catch {
+    _purify = null;
+  }
+  return _purify;
+}
+var SVG_ALLOWED_TAGS = ["svg", "g", "path", "circle", "rect", "line", "polyline", "polygon", "ellipse", "defs", "use", "symbol", "title", "desc", "clipPath", "mask", "linearGradient", "radialGradient", "stop", "pattern", "text", "tspan"];
+var SVG_ALLOWED_ATTR = ["viewBox", "xmlns", "fill", "stroke", "stroke-width", "stroke-linecap", "stroke-linejoin", "d", "cx", "cy", "r", "rx", "ry", "x", "y", "width", "height", "x1", "y1", "x2", "y2", "points", "transform", "opacity", "class", "id", "href", "xlink:href", "aria-hidden", "role", "focusable", "clip-path", "mask", "offset", "stop-color", "stop-opacity", "gradientUnits", "gradientTransform", "spreadMethod", "fx", "fy", "patternUnits", "patternContentUnits", "preserveAspectRatio"];
+async function sanitizeSVG(svgMarkup) {
+  if (typeof svgMarkup !== "string") return "";
+  const DOMPurify = await loadPurify();
+  if (DOMPurify?.sanitize) {
+    return DOMPurify.sanitize(svgMarkup, {
+      USE_PROFILES: { svg: true, svgFilters: true },
+      ADD_TAGS: SVG_ALLOWED_TAGS,
+      ADD_ATTR: SVG_ALLOWED_ATTR,
+      FORBID_TAGS: ["script", "foreignObject", "iframe", "object", "embed"],
+      FORBID_ATTR: ["onload", "onerror", "onclick", "onmouseover"]
+    });
+  }
+  return svgMarkup.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/<foreignObject[\s\S]*?<\/foreignObject>/gi, "");
+}
+
+export {
+  escapeHTML,
+  escapeHTMLAttribute,
+  sanitizeURL,
+  sanitizeSearchUrl,
+  sanitizeInputType,
+  sanitizeSVG
+};

package/dist/chunks/chunk-QTJJ3DPO.js

@@ -0,0 +1,109 @@
+// components/runtime/component-loaders.js
+var COMPONENT_LOADERS = {
+  "velin-accordion": () => import("./velin-accordion-FBIPAEXG.js"),
+  "velin-announcer": () => import("./velin-announcer-PVTXXCWR.js"),
+  "velin-bottom-nav": () => import("./velin-bottom-nav-2N2TYWOF.js"),
+  "velin-carousel": () => import("./velin-carousel-Y5VCOABZ.js"),
+  "velin-code-block": () => import("./velin-code-block-TSUKPY4C.js"),
+  "velin-collapse": () => import("./velin-collapse-5XYBUIID.js"),
+  "velin-combobox": () => import("./velin-combobox-2KDTCQ7N.js"),
+  "velin-command": () => import("./velin-command-M7RNHUPR.js"),
+  "velin-copy": () => import("./velin-copy-NYDBOKXT.js"),
+  "velin-countdown": () => import("./velin-countdown-4ZVDGK4R.js"),
+  "velin-counter": () => import("./velin-counter-ISCTEAHI.js"),
+  "velin-dialog": () => import("./velin-dialog-IJLFDXAJ.js"),
+  "velin-drawer": () => import("./velin-drawer-DLL2GLT6.js"),
+  "velin-dropdown": () => import("./velin-dropdown-PLUIFA5M.js"),
+  "velin-email": () => import("./velin-email-N5B5ZYTE.js"),
+  "velin-icon": () => import("./velin-icon-7M76DOPB.js"),
+  "velin-lightbox": () => import("./velin-lightbox-QOTB4PRL.js"),
+  "velin-live-dot": () => import("./velin-live-dot-XHUZCIDZ.js"),
+  "velin-menubar": () => import("./velin-menubar-SFEXJE56.js"),
+  "velin-modal": () => import("./velin-modal-5HYNNNUI.js"),
+  "velin-persist": () => import("./velin-persist-DFPL3QP4.js"),
+  "velin-popover": () => import("./velin-popover-EXINRIGJ.js"),
+  "velin-progress-ring": () => import("./velin-progress-ring-E4YRLZHH.js"),
+  "velin-rating": () => import("./velin-rating-N4DI2XNL.js"),
+  "velin-scroll-top": () => import("./velin-scroll-top-F2FCZNYD.js"),
+  "velin-scrollspy": () => import("./velin-scrollspy-OKCT4FDV.js"),
+  "velin-search": () => import("./velin-search-4YHJWYSS.js"),
+  "velin-secure-field": () => import("./velin-secure-field-6PV7RZDJ.js"),
+  "velin-segmented-control": () => import("./velin-segmented-control-GYD5BIXQ.js"),
+  "velin-sheet": () => import("./velin-sheet-OUK6572T.js"),
+  "velin-sparkline": () => import("./velin-sparkline-KDA3GQAN.js"),
+  "velin-stepper": () => import("./velin-stepper-FYEUEWE6.js"),
+  "velin-stepper-wc": () => import("./velin-stepper-FYEUEWE6.js"),
+  "velin-tabs": () => import("./velin-tabs-5UQ5ZVMV.js"),
+  "velin-theme-toggle": () => import("./velin-theme-toggle-NO7V4TWI.js"),
+  "velin-toast": () => import("./velin-toast-WEUBTJG6.js"),
+  "velin-tooltip": () => import("./velin-tooltip-664IOHZA.js"),
+  "velin-tooltip-wc": () => import("./velin-tooltip-664IOHZA.js")
+};
+
+// components/runtime/index.js
+var registry = /* @__PURE__ */ new Map();
+var VELIN_TAG_RE = /^velin-[a-z0-9-]+$/;
+function whenDefined(tagName) {
+  if (typeof customElements === "undefined") {
+    return Promise.reject(new Error("customElements not available"));
+  }
+  return customElements.whenDefined(tagName);
+}
+async function lazyDefine(tagName) {
+  const loader = COMPONENT_LOADERS[tagName];
+  if (!loader) {
+    throw new Error(`Unknown Velin component: ${tagName}`);
+  }
+  if (registry.has(tagName)) return registry.get(tagName);
+  const p = loader().then((mod) => {
+    const Cls = mod.default;
+    if (Cls && !customElements.get(tagName)) {
+      customElements.define(tagName, Cls);
+    }
+    return Cls;
+  });
+  registry.set(tagName, p);
+  return p;
+}
+async function register(tagNames) {
+  return Promise.all(tagNames.map((t) => lazyDefine(t)));
+}
+function collectTagsFromDOM(root) {
+  const tags = /* @__PURE__ */ new Set();
+  root.querySelectorAll("[data-velin-component]").forEach((el) => {
+    const name = el.getAttribute("data-velin-component");
+    if (name) tags.add(name.startsWith("velin-") ? name : `velin-${name}`);
+  });
+  for (const el of root.querySelectorAll("*")) {
+    const tag = el.tagName?.toLowerCase();
+    if (tag && VELIN_TAG_RE.test(tag) && COMPONENT_LOADERS[tag]) {
+      tags.add(tag);
+    }
+  }
+  return tags;
+}
+async function bootFromDOM(root = document, options = {}) {
+  const tags = options.tags?.length ? new Set(options.tags) : collectTagsFromDOM(root);
+  const wcPromise = register([...tags]);
+  if (options.attributes) {
+    const { bootAttributes } = await import("./attributes-JMYJZBPE.js");
+    await bootAttributes(root);
+  }
+  if (options.highlight) {
+    const { initHighlight } = await import("./highlight-GJHHV4KM.js");
+    initHighlight(root);
+  }
+  if (options.haptic) {
+    const { VelinHapticObserver } = await import("./velin-haptic-4QQTM3RK.js");
+    new VelinHapticObserver().start(root instanceof Document ? root.body : root);
+  }
+  return wcPromise;
+}
+
+export {
+  COMPONENT_LOADERS,
+  whenDefined,
+  lazyDefine,
+  register,
+  bootFromDOM
+};