@birdapi/velinstyle 1.0.0 → 1.2.0

package/dist/velinstyle-components.iife.js

@@ -316,7 +316,7 @@
   function createDOMPurify() {
     let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
     const DOMPurify = (root) => createDOMPurify(root);
-    DOMPurify.version = "3.4.5";
+    DOMPurify.version = "3.4.12";
     DOMPurify.removed = [];
     if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
       DOMPurify.isSupported = false;
@@ -325,14 +325,21 @@
     let document2 = window2.document;
     const originalDocument = document2;
     const currentScript = originalDocument.currentScript;
-    const DocumentFragment = window2.DocumentFragment, HTMLTemplateElement = window2.HTMLTemplateElement, Node = window2.Node, Element = window2.Element, NodeFilter = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap, HTMLFormElement = window2.HTMLFormElement, DOMParser2 = window2.DOMParser, trustedTypes = window2.trustedTypes;
+    window2.DocumentFragment;
+    const HTMLTemplateElement = window2.HTMLTemplateElement, Node = window2.Node, Element = window2.Element, NodeFilter = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap;
+    _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap;
+    window2.HTMLFormElement;
+    const DOMParser2 = window2.DOMParser, trustedTypes = window2.trustedTypes;
     const ElementPrototype = Element.prototype;
     const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
     const remove = lookupGetter(ElementPrototype, "remove");
     const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
     const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
     const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+    const getShadowRoot = lookupGetter(ElementPrototype, "shadowRoot");
+    const getAttributes = lookupGetter(ElementPrototype, "attributes");
     const getNodeType = Node && Node.prototype ? lookupGetter(Node.prototype, "nodeType") : null;
+    const getNodeName = Node && Node.prototype ? lookupGetter(Node.prototype, "nodeName") : null;
     if (typeof HTMLTemplateElement === "function") {
       const template = document2.createElement("template");
       if (template.content && template.content.ownerDocument) {
@@ -341,6 +348,39 @@
     }
     let trustedTypesPolicy;
     let emptyHTML = "";
+    let defaultTrustedTypesPolicy;
+    let defaultTrustedTypesPolicyResolved = false;
+    let IN_TRUSTED_TYPES_POLICY = 0;
+    const _assertNotInTrustedTypesPolicy = function _assertNotInTrustedTypesPolicy2() {
+      if (IN_TRUSTED_TYPES_POLICY > 0) {
+        throw typeErrorCreate('A configured TRUSTED_TYPES_POLICY callback (createHTML or createScriptURL) must not call DOMPurify.sanitize, as that causes infinite recursion. Do not pass a policy whose callbacks wrap DOMPurify as TRUSTED_TYPES_POLICY; see the "DOMPurify and Trusted Types" section of the README.');
+      }
+    };
+    const _createTrustedHTML = function _createTrustedHTML2(html2) {
+      _assertNotInTrustedTypesPolicy();
+      IN_TRUSTED_TYPES_POLICY++;
+      try {
+        return trustedTypesPolicy.createHTML(html2);
+      } finally {
+        IN_TRUSTED_TYPES_POLICY--;
+      }
+    };
+    const _createTrustedScriptURL = function _createTrustedScriptURL2(scriptUrl) {
+      _assertNotInTrustedTypesPolicy();
+      IN_TRUSTED_TYPES_POLICY++;
+      try {
+        return trustedTypesPolicy.createScriptURL(scriptUrl);
+      } finally {
+        IN_TRUSTED_TYPES_POLICY--;
+      }
+    };
+    const _getDefaultTrustedTypesPolicy = function _getDefaultTrustedTypesPolicy2() {
+      if (!defaultTrustedTypesPolicyResolved) {
+        defaultTrustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+        defaultTrustedTypesPolicyResolved = true;
+      }
+      return defaultTrustedTypesPolicy;
+    };
     const _document = document2, implementation = _document.implementation, createNodeIterator = _document.createNodeIterator, createDocumentFragment = _document.createDocumentFragment, getElementsByTagName = _document.getElementsByTagName;
     const importNode = originalDocument.importNode;
     let hooks = _createHooksMap();
@@ -395,6 +435,8 @@
     let SAFE_FOR_XML = true;
     let WHOLE_DOCUMENT = false;
     let SET_CONFIG = false;
+    let SET_CONFIG_ALLOWED_TAGS = null;
+    let SET_CONFIG_ALLOWED_ATTR = null;
     let FORCE_BODY = false;
     let RETURN_DOM = false;
     let RETURN_DOM_FRAGMENT = false;
@@ -406,7 +448,43 @@
     let IN_PLACE = false;
     let USE_PROFILES = {};
     let FORBID_CONTENTS = null;
-    const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+    const DEFAULT_FORBID_CONTENTS = addToSet({}, [
+      "annotation-xml",
+      "audio",
+      "colgroup",
+      "desc",
+      "foreignobject",
+      "head",
+      "iframe",
+      "math",
+      "mi",
+      "mn",
+      "mo",
+      "ms",
+      "mtext",
+      "noembed",
+      "noframes",
+      "noscript",
+      "plaintext",
+      "script",
+      // <selectedcontent> mirrors the selected <option>'s subtree, cloned by
+      // the UA (customizable <select>) — including any on* handlers — and the
+      // engine re-mirrors synchronously whenever a removal changes which
+      // option/selectedcontent is current, even inside DOMPurify's inert
+      // DOMParser document. Hoisting its children on removal re-inserts a fresh
+      // mirror target ahead of the walk, which the engine refills, looping
+      // forever (DoS) and amplifying output. Dropping its content on removal
+      // (rather than hoisting) breaks that cascade; the content is a duplicate
+      // of the option, which is sanitized on its own. See campaign-3 F1/F6.
+      "selectedcontent",
+      "style",
+      "svg",
+      "template",
+      "thead",
+      "title",
+      "video",
+      "xmp"
+    ]);
     let DATA_URI_TAGS = null;
     const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
     let URI_SAFE_ATTRIBUTES = null;
@@ -418,8 +496,10 @@
     let IS_EMPTY_INPUT = false;
     let ALLOWED_NAMESPACES = null;
     const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
-    let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
-    let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+    const DEFAULT_MATHML_TEXT_INTEGRATION_POINTS = freeze(["mi", "mo", "mn", "ms", "mtext"]);
+    let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, DEFAULT_MATHML_TEXT_INTEGRATION_POINTS);
+    const DEFAULT_HTML_INTEGRATION_POINTS = freeze(["annotation-xml"]);
+    let HTML_INTEGRATION_POINTS = addToSet({}, DEFAULT_HTML_INTEGRATION_POINTS);
     const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
     let PARSER_MEDIA_TYPE = null;
     const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
@@ -442,14 +522,32 @@
       PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
       SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
       transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
-      ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") && arrayIsArray(cfg.ALLOWED_TAGS) ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
-      ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") && arrayIsArray(cfg.ALLOWED_ATTR) ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
-      ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") && arrayIsArray(cfg.ALLOWED_NAMESPACES) ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
-      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") && arrayIsArray(cfg.ADD_URI_SAFE_ATTR) ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
-      DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") && arrayIsArray(cfg.ADD_DATA_URI_TAGS) ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
-      FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") && arrayIsArray(cfg.FORBID_CONTENTS) ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
-      FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") && arrayIsArray(cfg.FORBID_TAGS) ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
-      FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") && arrayIsArray(cfg.FORBID_ATTR) ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+      ALLOWED_TAGS = _resolveSetOption(cfg, "ALLOWED_TAGS", DEFAULT_ALLOWED_TAGS, {
+        transform: transformCaseFunc
+      });
+      ALLOWED_ATTR = _resolveSetOption(cfg, "ALLOWED_ATTR", DEFAULT_ALLOWED_ATTR, {
+        transform: transformCaseFunc
+      });
+      ALLOWED_NAMESPACES = _resolveSetOption(cfg, "ALLOWED_NAMESPACES", DEFAULT_ALLOWED_NAMESPACES, {
+        transform: stringToString
+      });
+      URI_SAFE_ATTRIBUTES = _resolveSetOption(cfg, "ADD_URI_SAFE_ATTR", DEFAULT_URI_SAFE_ATTRIBUTES, {
+        transform: transformCaseFunc,
+        base: DEFAULT_URI_SAFE_ATTRIBUTES
+      });
+      DATA_URI_TAGS = _resolveSetOption(cfg, "ADD_DATA_URI_TAGS", DEFAULT_DATA_URI_TAGS, {
+        transform: transformCaseFunc,
+        base: DEFAULT_DATA_URI_TAGS
+      });
+      FORBID_CONTENTS = _resolveSetOption(cfg, "FORBID_CONTENTS", DEFAULT_FORBID_CONTENTS, {
+        transform: transformCaseFunc
+      });
+      FORBID_TAGS = _resolveSetOption(cfg, "FORBID_TAGS", clone({}), {
+        transform: transformCaseFunc
+      });
+      FORBID_ATTR = _resolveSetOption(cfg, "FORBID_ATTR", clone({}), {
+        transform: transformCaseFunc
+      });
       USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES && typeof cfg.USE_PROFILES === "object" ? clone(cfg.USE_PROFILES) : cfg.USE_PROFILES : false;
       ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
       ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
@@ -468,8 +566,8 @@
       IN_PLACE = cfg.IN_PLACE || false;
       IS_ALLOWED_URI$1 = isRegex(cfg.ALLOWED_URI_REGEXP) ? cfg.ALLOWED_URI_REGEXP : IS_ALLOWED_URI;
       NAMESPACE = typeof cfg.NAMESPACE === "string" ? cfg.NAMESPACE : HTML_NAMESPACE;
-      MATHML_TEXT_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "MATHML_TEXT_INTEGRATION_POINTS") && cfg.MATHML_TEXT_INTEGRATION_POINTS && typeof cfg.MATHML_TEXT_INTEGRATION_POINTS === "object" ? clone(cfg.MATHML_TEXT_INTEGRATION_POINTS) : addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
-      HTML_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "HTML_INTEGRATION_POINTS") && cfg.HTML_INTEGRATION_POINTS && typeof cfg.HTML_INTEGRATION_POINTS === "object" ? clone(cfg.HTML_INTEGRATION_POINTS) : addToSet({}, ["annotation-xml"]);
+      MATHML_TEXT_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "MATHML_TEXT_INTEGRATION_POINTS") && cfg.MATHML_TEXT_INTEGRATION_POINTS && typeof cfg.MATHML_TEXT_INTEGRATION_POINTS === "object" ? clone(cfg.MATHML_TEXT_INTEGRATION_POINTS) : addToSet({}, DEFAULT_MATHML_TEXT_INTEGRATION_POINTS);
+      HTML_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "HTML_INTEGRATION_POINTS") && cfg.HTML_INTEGRATION_POINTS && typeof cfg.HTML_INTEGRATION_POINTS === "object" ? clone(cfg.HTML_INTEGRATION_POINTS) : addToSet({}, DEFAULT_HTML_INTEGRATION_POINTS);
       const customElementHandling = objectHasOwnProperty(cfg, "CUSTOM_ELEMENT_HANDLING") && cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING === "object" ? clone(cfg.CUSTOM_ELEMENT_HANDLING) : create(null);
       CUSTOM_ELEMENT_HANDLING = create(null);
       if (objectHasOwnProperty(customElementHandling, "tagNameCheck") && isRegexOrFunction(customElementHandling.tagNameCheck)) {
@@ -481,6 +579,7 @@
       if (objectHasOwnProperty(customElementHandling, "allowCustomizedBuiltInElements") && typeof customElementHandling.allowCustomizedBuiltInElements === "boolean") {
         CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = customElementHandling.allowCustomizedBuiltInElements;
       }
+      seal(CUSTOM_ELEMENT_HANDLING);
       if (SAFE_FOR_TEMPLATES) {
         ALLOW_DATA_ATTR = false;
       }
@@ -564,14 +663,23 @@
         if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
           throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
         }
+        const previousTrustedTypesPolicy = trustedTypesPolicy;
         trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
-        emptyHTML = trustedTypesPolicy.createHTML("");
+        try {
+          emptyHTML = _createTrustedHTML("");
+        } catch (error) {
+          trustedTypesPolicy = previousTrustedTypesPolicy;
+          throw error;
+        }
+      } else if (cfg.TRUSTED_TYPES_POLICY === null) {
+        trustedTypesPolicy = void 0;
+        emptyHTML = "";
       } else {
         if (trustedTypesPolicy === void 0) {
-          trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+          trustedTypesPolicy = _getDefaultTrustedTypesPolicy();
         }
-        if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
-          emptyHTML = trustedTypesPolicy.createHTML("");
+        if (trustedTypesPolicy && typeof emptyHTML === "string") {
+          emptyHTML = _createTrustedHTML("");
         }
       }
       if (freeze) {
@@ -581,6 +689,33 @@
     };
     const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
     const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+    const _checkSvgNamespace = function _checkSvgNamespace2(tagName, parent, parentTagName) {
+      if (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "svg";
+      }
+      if (parent.namespaceURI === MATHML_NAMESPACE) {
+        return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+      }
+      return Boolean(ALL_SVG_TAGS[tagName]);
+    };
+    const _checkMathMlNamespace = function _checkMathMlNamespace2(tagName, parent, parentTagName) {
+      if (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "math";
+      }
+      if (parent.namespaceURI === SVG_NAMESPACE) {
+        return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+      }
+      return Boolean(ALL_MATHML_TAGS[tagName]);
+    };
+    const _checkHtmlNamespace = function _checkHtmlNamespace2(tagName, parent, parentTagName) {
+      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+    };
     const _checkValidNamespace = function _checkValidNamespace2(element) {
       let parent = getParentNode(element);
       if (!parent || !parent.tagName) {
@@ -595,31 +730,13 @@
         return false;
       }
       if (element.namespaceURI === SVG_NAMESPACE) {
-        if (parent.namespaceURI === HTML_NAMESPACE) {
-          return tagName === "svg";
-        }
-        if (parent.namespaceURI === MATHML_NAMESPACE) {
-          return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
-        }
-        return Boolean(ALL_SVG_TAGS[tagName]);
+        return _checkSvgNamespace(tagName, parent, parentTagName);
       }
       if (element.namespaceURI === MATHML_NAMESPACE) {
-        if (parent.namespaceURI === HTML_NAMESPACE) {
-          return tagName === "math";
-        }
-        if (parent.namespaceURI === SVG_NAMESPACE) {
-          return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
-        }
-        return Boolean(ALL_MATHML_TAGS[tagName]);
+        return _checkMathMlNamespace(tagName, parent, parentTagName);
       }
       if (element.namespaceURI === HTML_NAMESPACE) {
-        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
-          return false;
-        }
-        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
-          return false;
-        }
-        return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+        return _checkHtmlNamespace(tagName, parent, parentTagName);
       }
       if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
         return true;
@@ -634,6 +751,38 @@
         getParentNode(node).removeChild(node);
       } catch (_) {
         remove(node);
+        if (!getParentNode(node)) {
+          throw typeErrorCreate("a node selected for removal could not be detached from its tree and cannot be safely returned; refusing to sanitize in place");
+        }
+      }
+    };
+    const _neutralizeRoot = function _neutralizeRoot2(root) {
+      _neutralizeSubtree(root);
+      const childNodes = getChildNodes(root);
+      if (childNodes) {
+        const snapshot = [];
+        arrayForEach(childNodes, (child) => {
+          arrayPush(snapshot, child);
+        });
+        arrayForEach(snapshot, (child) => {
+          try {
+            remove(child);
+          } catch (_) {
+          }
+        });
+      }
+      const attributes = getAttributes(root);
+      if (attributes) {
+        for (let i = attributes.length - 1; i >= 0; --i) {
+          const attribute = attributes[i];
+          const name = attribute && attribute.name;
+          if (typeof name === "string") {
+            try {
+              root.removeAttribute(name);
+            } catch (_) {
+            }
+          }
+        }
       }
     };
     const _removeAttribute = function _removeAttribute2(name, element) {
@@ -663,6 +812,75 @@
         }
       }
     };
+    const _stripDisallowedAttributes = function _stripDisallowedAttributes2(element) {
+      const attributes = getAttributes(element);
+      if (!attributes) {
+        return;
+      }
+      for (let i = attributes.length - 1; i >= 0; --i) {
+        const attribute = attributes[i];
+        const name = attribute && attribute.name;
+        if (typeof name !== "string" || ALLOWED_ATTR[transformCaseFunc(name)]) {
+          continue;
+        }
+        try {
+          element.removeAttribute(name);
+        } catch (_) {
+        }
+      }
+    };
+    const _neutralizeSubtree = function _neutralizeSubtree2(root) {
+      const stack = [root];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        const nodeType = getNodeType ? getNodeType(node) : node.nodeType;
+        if (nodeType === NODE_TYPE.element) {
+          _stripDisallowedAttributes(node);
+        }
+        const childNodes = getChildNodes(node);
+        if (childNodes) {
+          for (let i = childNodes.length - 1; i >= 0; --i) {
+            stack.push(childNodes[i]);
+          }
+        }
+      }
+    };
+    const _neutralizePatchLinkage = function _neutralizePatchLinkage2(root) {
+      if (!SAFE_FOR_XML) {
+        return;
+      }
+      const stack = [root];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        const nodeType = getNodeType ? getNodeType(node) : node.nodeType;
+        if (nodeType === NODE_TYPE.processingInstruction || nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, node.data)) {
+          try {
+            remove(node);
+          } catch (_) {
+          }
+          continue;
+        }
+        if (nodeType === NODE_TYPE.element) {
+          const element = node;
+          const lcTag = transformCaseFunc(getNodeName ? getNodeName(node) : node.nodeName);
+          try {
+            if (element.hasAttribute && element.hasAttribute("patchsrc")) {
+              element.removeAttribute("patchsrc");
+            }
+            if (element.hasAttribute && element.hasAttribute("for") && lcTag !== "label" && lcTag !== "output") {
+              element.removeAttribute("for");
+            }
+          } catch (_) {
+          }
+        }
+        const childNodes = getChildNodes(node);
+        if (childNodes) {
+          for (let i = childNodes.length - 1; i >= 0; --i) {
+            stack.push(childNodes[i]);
+          }
+        }
+      }
+    };
     const _initDocument = function _initDocument2(dirty) {
       let doc = null;
       let leadingWhitespace = null;
@@ -675,7 +893,7 @@
       if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
         dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
       }
-      const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      const dirtyPayload = trustedTypesPolicy ? _createTrustedHTML(dirty) : dirty;
       if (NAMESPACE === HTML_NAMESPACE) {
         try {
           doc = new DOMParser2().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
@@ -707,7 +925,14 @@
         null
       );
     };
-    const _scrubTemplateExpressions = function _scrubTemplateExpressions2(node) {
+    const _stripTemplateExpressions = function _stripTemplateExpressions2(value) {
+      value = stringReplace(value, MUSTACHE_EXPR$1, " ");
+      value = stringReplace(value, ERB_EXPR$1, " ");
+      value = stringReplace(value, TMPLIT_EXPR$1, " ");
+      return value;
+    };
+    const _scrubTemplateExpressions2 = function _scrubTemplateExpressions(node) {
+      var _node$querySelectorAl;
       node.normalize();
       const walker = createNodeIterator.call(
         node.ownerDocument || node,
@@ -718,16 +943,60 @@
       );
       let currentNode = walker.nextNode();
       while (currentNode) {
-        let data = currentNode.data;
-        arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
-          data = stringReplace(data, expr, " ");
-        });
-        currentNode.data = data;
+        currentNode.data = _stripTemplateExpressions(currentNode.data);
         currentNode = walker.nextNode();
       }
+      const templates = (_node$querySelectorAl = node.querySelectorAll) === null || _node$querySelectorAl === void 0 ? void 0 : _node$querySelectorAl.call(node, "template");
+      if (templates) {
+        arrayForEach(templates, (tmpl) => {
+          if (_isDocumentFragment(tmpl.content)) {
+            _scrubTemplateExpressions2(tmpl.content);
+          }
+        });
+      }
     };
     const _isClobbered = function _isClobbered2(element) {
-      return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+      const realTagName = getNodeName ? getNodeName(element) : null;
+      if (typeof realTagName !== "string") {
+        return false;
+      }
+      if (transformCaseFunc(realTagName) !== "form") {
+        return false;
+      }
+      return typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || // Realm-safe NamedNodeMap detection: equality against the cached
+      // prototype getter. Clobbered .attributes (e.g. <input name="attributes">)
+      // makes the direct read diverge from the cached read; a clean form
+      // (same-realm OR foreign-realm) has both reads pointing at the same
+      // canonical NamedNodeMap.
+      element.attributes !== getAttributes(element) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function" || // NodeType clobbering probe. Cached Node.prototype.nodeType getter
+      // returns the integer 1 for any Element regardless of realm; direct
+      // read on a clobbered form (e.g. <input name="nodeType">) returns
+      // the named child element. Cheap addition — nodeType is read from
+      // an internal slot, no serialization cost — and removes a residual
+      // clobbering surface used by several mXSS / PI / comment branches
+      // in _sanitizeElements that compare currentNode.nodeType directly.
+      element.nodeType !== getNodeType(element) || // HTMLFormElement has [LegacyOverrideBuiltIns]: a descendant named
+      // "childNodes" shadows the prototype getter. Direct reads of
+      // form.childNodes from a clobbered form return the named child
+      // instead of the real NodeList, so any walk that reads it directly
+      // skips the form's real children. Compare the direct read to the
+      // cached Node.prototype getter — when the form's named-property
+      // getter intercepts the read, the two values differ and we flag
+      // the form. This catches every clobbering child type (input,
+      // select, etc.) regardless of whether the named child happens to
+      // carry a numeric .length, which a typeof-based probe would miss
+      // (e.g. HTMLSelectElement.length is a defined unsigned-long).
+      element.childNodes !== getChildNodes(element);
+    };
+    const _isDocumentFragment = function _isDocumentFragment2(value) {
+      if (!getNodeType || typeof value !== "object" || value === null) {
+        return false;
+      }
+      try {
+        return getNodeType(value) === NODE_TYPE.documentFragment;
+      } catch (_) {
+        return false;
+      }
     };
     const _isNode = function _isNode2(value) {
       if (!getNodeType || typeof value !== "object" || value === null) {
@@ -740,74 +1009,90 @@
       }
     };
     function _executeHooks(hooks2, currentNode, data) {
+      if (hooks2.length === 0) {
+        return;
+      }
       arrayForEach(hooks2, (hook) => {
         hook.call(DOMPurify, currentNode, data, CONFIG);
       });
     }
-    const _sanitizeElements = function _sanitizeElements2(currentNode) {
-      let content = null;
+    const _isUnsafeNode = function _isUnsafeNode2(currentNode, tagName) {
+      if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.innerHTML)) {
+        return true;
+      }
+      if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && tagName === "style" && _isNode(currentNode.firstElementChild)) {
+        return true;
+      }
+      if (currentNode.nodeType === NODE_TYPE.processingInstruction) {
+        return true;
+      }
+      if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, currentNode.data)) {
+        return true;
+      }
+      return false;
+    };
+    const _sanitizeDisallowedNode = function _sanitizeDisallowedNode2(currentNode, tagName) {
+      if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+          return false;
+        }
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+          return false;
+        }
+      }
+      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+        const parentNode = getParentNode(currentNode);
+        const childNodes = getChildNodes(currentNode);
+        if (childNodes && parentNode) {
+          const childCount = childNodes.length;
+          for (let i = childCount - 1; i >= 0; --i) {
+            const hoisted = IN_PLACE ? childNodes[i] : cloneNode(childNodes[i], true);
+            parentNode.insertBefore(hoisted, getNextSibling(currentNode));
+          }
+        }
+      }
+      _forceRemove(currentNode);
+      return true;
+    };
+    const _sanitizeElements = function _sanitizeElements2(currentNode, root) {
       _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+      if (currentNode !== root && getParentNode(currentNode) === null) {
+        return true;
+      }
       if (_isClobbered(currentNode)) {
         _forceRemove(currentNode);
         return true;
       }
-      const tagName = transformCaseFunc(currentNode.nodeName);
+      const tagName = transformCaseFunc(getNodeName ? getNodeName(currentNode) : currentNode.nodeName);
       _executeHooks(hooks.uponSanitizeElement, currentNode, {
         tagName,
         allowedTags: ALLOWED_TAGS
       });
-      if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
-        _forceRemove(currentNode);
-        return true;
-      }
-      if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && tagName === "style" && _isNode(currentNode.firstElementChild)) {
-        _forceRemove(currentNode);
-        return true;
-      }
-      if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
-        _forceRemove(currentNode);
+      if (currentNode !== root && getParentNode(currentNode) === null) {
         return true;
       }
-      if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+      if (_isUnsafeNode(currentNode, tagName)) {
         _forceRemove(currentNode);
         return true;
       }
       if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
-        if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
-          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
-            return false;
-          }
-          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
-            return false;
-          }
-        }
-        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
-          const parentNode = getParentNode(currentNode) || currentNode.parentNode;
-          const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
-          if (childNodes && parentNode) {
-            const childCount = childNodes.length;
-            for (let i = childCount - 1; i >= 0; --i) {
-              const childClone = cloneNode(childNodes[i], true);
-              parentNode.insertBefore(childClone, getNextSibling(currentNode));
-            }
-          }
+        const removed2 = _sanitizeDisallowedNode(currentNode, tagName);
+        if (removed2 === false) {
+          _executeHooks(hooks.afterSanitizeElements, currentNode, null);
         }
-        _forceRemove(currentNode);
-        return true;
+        return removed2;
       }
-      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+      const nt = getNodeType ? getNodeType(currentNode) : currentNode.nodeType;
+      if (nt === NODE_TYPE.element && !_checkValidNamespace(currentNode)) {
         _forceRemove(currentNode);
         return true;
       }
-      if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+      if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(FALLBACK_TAG_CLOSE, currentNode.innerHTML)) {
         _forceRemove(currentNode);
         return true;
       }
       if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
-        content = currentNode.textContent;
-        arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
-          content = stringReplace(content, expr, " ");
-        });
+        const content = _stripTemplateExpressions(currentNode.textContent);
         if (currentNode.textContent !== content) {
           arrayPush(DOMPurify.removed, {
             element: currentNode.cloneNode()
@@ -822,13 +1107,19 @@
       if (FORBID_ATTR[lcName]) {
         return false;
       }
+      if (SAFE_FOR_XML && lcName === "patchsrc") {
+        return false;
+      }
+      if (SAFE_FOR_XML && lcName === "for" && lcTag !== "label" && lcTag !== "output") {
+        return false;
+      }
       if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
         return false;
       }
       const nameIsPermitted = ALLOWED_ATTR[lcName] || EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag);
-      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName)) ;
+      if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$1, lcName)) ;
       else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) ;
-      else if (!nameIsPermitted || FORBID_ATTR[lcName]) {
+      else if (!nameIsPermitted) {
         if (
           // First condition does a very basic check if a) it's basically a valid custom element tagname AND
           // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
@@ -853,6 +1144,35 @@
     const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
       return !RESERVED_CUSTOM_ELEMENT_NAMES[stringToLowerCase(tagName)] && regExpTest(CUSTOM_ELEMENT$1, tagName);
     };
+    const _applyTrustedTypesToAttribute = function _applyTrustedTypesToAttribute2(lcTag, lcName, namespaceURI, value) {
+      if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function" && !namespaceURI) {
+        switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+          case "TrustedHTML": {
+            return _createTrustedHTML(value);
+          }
+          case "TrustedScriptURL": {
+            return _createTrustedScriptURL(value);
+          }
+        }
+      }
+      return value;
+    };
+    const _setAttributeValue = function _setAttributeValue2(currentNode, name, namespaceURI, value) {
+      try {
+        if (namespaceURI) {
+          currentNode.setAttributeNS(namespaceURI, name, value);
+        } else {
+          currentNode.setAttribute(name, value);
+        }
+        if (_isClobbered(currentNode)) {
+          _forceRemove(currentNode);
+        } else {
+          arrayPop(DOMPurify.removed);
+        }
+      } catch (_) {
+        _removeAttribute(name, currentNode);
+      }
+    };
     const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
       _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
       const attributes = currentNode.attributes;
@@ -867,6 +1187,7 @@
         forceKeepAttr: void 0
       };
       let l = attributes.length;
+      const lcTag = transformCaseFunc(currentNode.nodeName);
       while (l--) {
         const attr = attributes[l];
         const name = attr.name, namespaceURI = attr.namespaceURI, attrValue = attr.value;
@@ -898,50 +1219,20 @@
           _removeAttribute(name, currentNode);
           continue;
         }
-        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value)) {
           _removeAttribute(name, currentNode);
           continue;
         }
         if (SAFE_FOR_TEMPLATES) {
-          arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
-            value = stringReplace(value, expr, " ");
-          });
+          value = _stripTemplateExpressions(value);
         }
-        const lcTag = transformCaseFunc(currentNode.nodeName);
         if (!_isValidAttribute(lcTag, lcName, value)) {
           _removeAttribute(name, currentNode);
           continue;
         }
-        if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
-          if (namespaceURI) ;
-          else {
-            switch (trustedTypes.getAttributeType(lcTag, lcName)) {
-              case "TrustedHTML": {
-                value = trustedTypesPolicy.createHTML(value);
-                break;
-              }
-              case "TrustedScriptURL": {
-                value = trustedTypesPolicy.createScriptURL(value);
-                break;
-              }
-            }
-          }
-        }
+        value = _applyTrustedTypesToAttribute(lcTag, lcName, namespaceURI, value);
         if (value !== initValue) {
-          try {
-            if (namespaceURI) {
-              currentNode.setAttributeNS(namespaceURI, name, value);
-            } else {
-              currentNode.setAttribute(name, value);
-            }
-            if (_isClobbered(currentNode)) {
-              _forceRemove(currentNode);
-            } else {
-              arrayPop(DOMPurify.removed);
-            }
-          } catch (_) {
-            _removeAttribute(name, currentNode);
-          }
+          _setAttributeValue(currentNode, name, namespaceURI, value);
         }
       }
       _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
@@ -952,30 +1243,69 @@
       _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
       while (shadowNode = shadowIterator.nextNode()) {
         _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
-        _sanitizeElements(shadowNode);
+        _sanitizeElements(shadowNode, fragment);
         _sanitizeAttributes(shadowNode);
-        if (shadowNode.content instanceof DocumentFragment) {
+        if (_isDocumentFragment(shadowNode.content)) {
           _sanitizeShadowDOM2(shadowNode.content);
         }
+        const shadowNodeType = getNodeType ? getNodeType(shadowNode) : shadowNode.nodeType;
+        if (shadowNodeType === NODE_TYPE.element) {
+          const innerSr = getShadowRoot(shadowNode);
+          if (_isDocumentFragment(innerSr)) {
+            _sanitizeAttachedShadowRoots(innerSr);
+            _sanitizeShadowDOM2(innerSr);
+          }
+        }
       }
       _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
     };
-    const _sanitizeAttachedShadowRoots2 = function _sanitizeAttachedShadowRoots(root) {
-      if (root.nodeType === NODE_TYPE.element && root.shadowRoot instanceof DocumentFragment) {
-        const sr = root.shadowRoot;
-        _sanitizeAttachedShadowRoots2(sr);
-        _sanitizeShadowDOM2(sr);
-      }
-      const childNodes = root.childNodes;
-      if (!childNodes) {
-        return;
-      }
-      const snapshot = [];
-      arrayForEach(childNodes, (child) => {
-        arrayPush(snapshot, child);
-      });
-      for (const child of snapshot) {
-        _sanitizeAttachedShadowRoots2(child);
+    const _sanitizeAttachedShadowRoots = function _sanitizeAttachedShadowRoots2(root) {
+      const stack = [{
+        node: root,
+        shadow: null
+      }];
+      while (stack.length > 0) {
+        const item = stack.pop();
+        if (item.shadow) {
+          _sanitizeShadowDOM2(item.shadow);
+          continue;
+        }
+        const node = item.node;
+        const nodeType = getNodeType ? getNodeType(node) : node.nodeType;
+        const isElement = nodeType === NODE_TYPE.element;
+        const childNodes = getChildNodes(node);
+        if (childNodes) {
+          for (let i = childNodes.length - 1; i >= 0; --i) {
+            stack.push({
+              node: childNodes[i],
+              shadow: null
+            });
+          }
+        }
+        if (isElement) {
+          const rootName = getNodeName ? getNodeName(node) : null;
+          if (typeof rootName === "string" && transformCaseFunc(rootName) === "template") {
+            const content = node.content;
+            if (_isDocumentFragment(content)) {
+              stack.push({
+                node: content,
+                shadow: null
+              });
+            }
+          }
+        }
+        if (isElement) {
+          const sr = getShadowRoot(node);
+          if (_isDocumentFragment(sr)) {
+            stack.push({
+              node: null,
+              shadow: sr
+            }, {
+              node: sr,
+              shadow: null
+            });
+          }
+        }
       }
     };
     DOMPurify.sanitize = function(dirty) {
@@ -997,22 +1327,40 @@
       if (!DOMPurify.isSupported) {
         return dirty;
       }
-      if (!SET_CONFIG) {
+      if (SET_CONFIG) {
+        ALLOWED_TAGS = SET_CONFIG_ALLOWED_TAGS;
+        ALLOWED_ATTR = SET_CONFIG_ALLOWED_ATTR;
+      } else {
         _parseConfig(cfg);
       }
-      DOMPurify.removed = [];
-      if (typeof dirty === "string") {
-        IN_PLACE = false;
+      if (hooks.uponSanitizeElement.length > 0 || hooks.uponSanitizeAttribute.length > 0) {
+        ALLOWED_TAGS = clone(ALLOWED_TAGS);
       }
-      if (IN_PLACE) {
-        const nn = dirty.nodeName;
+      if (hooks.uponSanitizeAttribute.length > 0) {
+        ALLOWED_ATTR = clone(ALLOWED_ATTR);
+      }
+      DOMPurify.removed = [];
+      const inPlace = IN_PLACE && typeof dirty !== "string" && _isNode(dirty);
+      if (inPlace) {
+        _neutralizePatchLinkage(dirty);
+        const nn = getNodeName ? getNodeName(dirty) : dirty.nodeName;
         if (typeof nn === "string") {
           const tagName = transformCaseFunc(nn);
           if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+            _neutralizeRoot(dirty);
             throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
           }
         }
-        _sanitizeAttachedShadowRoots2(dirty);
+        if (_isClobbered(dirty)) {
+          _neutralizeRoot(dirty);
+          throw typeErrorCreate("root node is clobbered and cannot be sanitized in-place");
+        }
+        try {
+          _sanitizeAttachedShadowRoots(dirty);
+        } catch (error) {
+          _neutralizeRoot(dirty);
+          throw error;
+        }
       } else if (_isNode(dirty)) {
         body = _initDocument("<!---->");
         importedNode = body.ownerDocument.importNode(dirty, true);
@@ -1023,11 +1371,11 @@
         } else {
           body.appendChild(importedNode);
         }
-        _sanitizeAttachedShadowRoots2(importedNode);
+        _sanitizeAttachedShadowRoots(importedNode);
       } else {
         if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
         dirty.indexOf("<") === -1) {
-          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(dirty) : dirty;
         }
         body = _initDocument(dirty);
         if (!body) {
@@ -1037,23 +1385,41 @@
       if (body && FORCE_BODY) {
         _forceRemove(body.firstChild);
       }
-      const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
-      while (currentNode = nodeIterator.nextNode()) {
-        _sanitizeElements(currentNode);
-        _sanitizeAttributes(currentNode);
-        if (currentNode.content instanceof DocumentFragment) {
-          _sanitizeShadowDOM2(currentNode.content);
+      const walkRoot = inPlace ? dirty : body;
+      const nodeIterator = _createNodeIterator(walkRoot);
+      try {
+        while (currentNode = nodeIterator.nextNode()) {
+          _sanitizeElements(currentNode, walkRoot);
+          _sanitizeAttributes(currentNode);
+          if (_isDocumentFragment(currentNode.content)) {
+            _sanitizeShadowDOM2(currentNode.content);
+          }
+        }
+      } catch (error) {
+        if (inPlace) {
+          _neutralizeRoot(dirty);
+          arrayForEach(DOMPurify.removed, (entry) => {
+            if (entry.element) {
+              _neutralizeSubtree(entry.element);
+            }
+          });
         }
+        throw error;
       }
-      if (IN_PLACE) {
+      if (inPlace) {
+        arrayForEach(DOMPurify.removed, (entry) => {
+          if (entry.element) {
+            _neutralizeSubtree(entry.element);
+          }
+        });
         if (SAFE_FOR_TEMPLATES) {
-          _scrubTemplateExpressions(dirty);
+          _scrubTemplateExpressions2(dirty);
         }
         return dirty;
       }
       if (RETURN_DOM) {
         if (SAFE_FOR_TEMPLATES) {
-          _scrubTemplateExpressions(body);
+          _scrubTemplateExpressions2(body);
         }
         if (RETURN_DOM_FRAGMENT) {
           returnNode = createDocumentFragment.call(body.ownerDocument);
@@ -1073,20 +1439,24 @@
         serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
       }
       if (SAFE_FOR_TEMPLATES) {
-        arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
-          serializedHTML = stringReplace(serializedHTML, expr, " ");
-        });
+        serializedHTML = _stripTemplateExpressions(serializedHTML);
       }
-      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(serializedHTML) : serializedHTML;
     };
     DOMPurify.setConfig = function() {
       let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
       _parseConfig(cfg);
       SET_CONFIG = true;
+      SET_CONFIG_ALLOWED_TAGS = ALLOWED_TAGS;
+      SET_CONFIG_ALLOWED_ATTR = ALLOWED_ATTR;
     };
     DOMPurify.clearConfig = function() {
       CONFIG = null;
       SET_CONFIG = false;
+      SET_CONFIG_ALLOWED_TAGS = null;
+      SET_CONFIG_ALLOWED_ATTR = null;
+      trustedTypesPolicy = defaultTrustedTypesPolicy;
+      emptyHTML = "";
     };
     DOMPurify.isValidAttribute = function(tag, attr, value) {
       if (!CONFIG) {
@@ -1100,9 +1470,15 @@
       if (typeof hookFunction !== "function") {
         return;
       }
+      if (!objectHasOwnProperty(hooks, entryPoint)) {
+        return;
+      }
       arrayPush(hooks[entryPoint], hookFunction);
     };
     DOMPurify.removeHook = function(entryPoint, hookFunction) {
+      if (!objectHasOwnProperty(hooks, entryPoint)) {
+        return void 0;
+      }
       if (hookFunction !== void 0) {
         const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
         return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
@@ -1110,6 +1486,9 @@
       return arrayPop(hooks[entryPoint]);
     };
     DOMPurify.removeHooks = function(entryPoint) {
+      if (!objectHasOwnProperty(hooks, entryPoint)) {
+        return;
+      }
       hooks[entryPoint] = [];
     };
     DOMPurify.removeAllHooks = function() {
@@ -1117,7 +1496,7 @@
     };
     return DOMPurify;
   }
-  var entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, freeze, seal, create, _ref, apply, construct, arrayForEach, arrayLastIndexOf, arrayPop, arrayPush, arraySplice, arrayIsArray, stringToLowerCase, stringToString, stringMatch, stringReplace, stringIndexOf, stringTrim, numberToString, booleanToString, bigintToString, symbolToString, objectHasOwnProperty, objectToString, regExpTest, typeErrorCreate, html$1, svg$1, svgFilters, svgDisallowed, mathMl$1, mathMlDisallowed, text, html, svg, mathMl, xml, MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_ALLOWED_URI, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, DOCTYPE_NAME, CUSTOM_ELEMENT, NODE_TYPE, getGlobal, _createTrustedTypesPolicy, _createHooksMap, purify;
+  var entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, freeze, seal, create, _ref, apply, construct, arrayForEach, arrayLastIndexOf, arrayPop, arrayPush, arraySplice, arrayIsArray, stringToLowerCase, stringToString, stringMatch, stringReplace, stringIndexOf, stringTrim, numberToString, booleanToString, bigintToString, symbolToString, objectHasOwnProperty, objectToString, regExpTest, typeErrorCreate, html$1, svg$1, svgFilters, svgDisallowed, mathMl$1, mathMlDisallowed, text, html, svg, mathMl, xml, MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_ALLOWED_URI, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, DOCTYPE_NAME, CUSTOM_ELEMENT, ELEMENT_MARKUP_PROBE, COMMENT_MARKUP_PROBE, FALLBACK_TAG_CLOSE, SELF_CLOSING_TAG, NODE_TYPE, getGlobal, _createTrustedTypesPolicy, _createHooksMap, _resolveSetOption, purify;
   var init_purify_es = __esm({
     "node_modules/dompurify/dist/purify.es.mjs"() {
       entries = Object.entries;
@@ -1185,7 +1564,7 @@
       mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
       text = freeze(["#text"]);
       html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "command", "commandfor", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns"]);
-      svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+      svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dominant-baseline", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-orientation", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
       mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnalign", "columnlines", "columnspacing", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lquote", "lspace", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
       xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
       MUSTACHE_EXPR = seal(/{{[\w\W]*|^[\w\W]*}}/g);
@@ -1204,13 +1583,26 @@
       );
       DOCTYPE_NAME = seal(/^html$/i);
       CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+      ELEMENT_MARKUP_PROBE = seal(/<[/\w!]/g);
+      COMMENT_MARKUP_PROBE = seal(/<[/\w]/g);
+      FALLBACK_TAG_CLOSE = seal(/<\/no(script|embed|frames)/i);
+      SELF_CLOSING_TAG = seal(/\/>/i);
       NODE_TYPE = {
         element: 1,
+        attribute: 2,
         text: 3,
+        cdataSection: 4,
+        entityReference: 5,
         // Deprecated
-        progressingInstruction: 7,
+        entityNode: 6,
+        // Deprecated
+        processingInstruction: 7,
         comment: 8,
-        document: 9
+        document: 9,
+        documentType: 10,
+        documentFragment: 11,
+        notation: 12
+        // Deprecated
       };
       getGlobal = function getGlobal2() {
         return typeof window === "undefined" ? null : window;
@@ -1252,6 +1644,9 @@
           uponSanitizeShadowNode: []
         };
       };
+      _resolveSetOption = function _resolveSetOption2(cfg, key, fallback, options) {
+        return objectHasOwnProperty(cfg, key) && arrayIsArray(cfg[key]) ? addToSet(options.base ? clone(options.base) : {}, cfg[key], options.transform) : fallback;
+      };
       purify = createDOMPurify();
     }
   });
@@ -1541,7 +1936,6 @@
           this._previouslyFocused = saveFocus();
           setBackgroundInert(this);
           document.addEventListener("keydown", this._onKeydown);
-          document.body.style.overflow = "hidden";
           requestAnimationFrame(() => {
             const focusable = getFocusableElements(this.shadowRoot);
             if (focusable.length > 0) focusable[0].focus();
@@ -1549,8 +1943,7 @@
         }
         _close() {
           document.removeEventListener("keydown", this._onKeydown);
-          document.body.style.overflow = "";
-          clearBackgroundInert();
+          clearBackgroundInert(this);
           restoreFocus(this._previouslyFocused);
         }
         _onKeydown(event) {
@@ -1562,7 +1955,7 @@
         }
         disconnectedCallback() {
           document.removeEventListener("keydown", this._onKeydown);
-          document.body.style.overflow = "";
+          clearBackgroundInert(this);
         }
       };
       customElements.define("velin-modal", VelinModal);
@@ -1751,26 +2144,36 @@
   __export(velin_accordion_exports, {
     default: () => velin_accordion_default
   });
-  var styles3, VelinAccordion, velin_accordion_default;
+  function ensureLightStyles() {
+    if (typeof document === "undefined") return;
+    if (document.getElementById(LIGHT_STYLE_ID)) return;
+    const style = document.createElement("style");
+    style.id = LIGHT_STYLE_ID;
+    style.textContent = lightStyles;
+    document.head.appendChild(style);
+  }
+  var LIGHT_STYLE_ID, lightStyles, shadowStyles, VelinAccordion, velin_accordion_default;
   var init_velin_accordion = __esm({
     "components/velin-accordion.js"() {
-      styles3 = `
-  :host {
+      LIGHT_STYLE_ID = "velin-accordion-light-css";
+      lightStyles = `
+  velin-accordion {
     display: block;
     border: 1px solid var(--velin-color-border, #ddd);
     border-radius: var(--velin-radius-md, 0.5rem);
     overflow: hidden;
   }
-  ::slotted(details) {
+  velin-accordion details {
     border-bottom: 1px solid var(--velin-color-border, #ddd);
   }
-  ::slotted(details:last-child) {
+  velin-accordion details:last-child {
     border-bottom: none;
   }
-  ::slotted(details > summary) {
+  velin-accordion details > summary {
     display: flex;
     align-items: center;
     justify-content: space-between;
+    gap: var(--velin-space-3, 0.75rem);
     padding: var(--velin-space-4, 1rem);
     min-block-size: 2.75rem;
     font-size: var(--velin-text-base, 1rem);
@@ -1779,37 +2182,57 @@
     user-select: none;
     list-style: none;
   }
-  ::slotted(details > summary::-webkit-details-marker) {
+  velin-accordion details > summary::-webkit-details-marker {
     display: none;
   }
-  ::slotted(details[open] > summary) {
+  velin-accordion details > summary::after {
+    content: "";
+    flex-shrink: 0;
+    inline-size: 0.5rem;
+    block-size: 0.5rem;
+    border-inline-end: 2px solid currentColor;
+    border-block-end: 2px solid currentColor;
+    transform: rotate(45deg);
+    transition: transform 150ms ease;
+  }
+  velin-accordion details[open] > summary {
     background: var(--velin-color-primary-subtle, #eff6ff);
     color: var(--velin-color-primary, #2563eb);
   }
-  ::slotted(details > :not(summary)) {
+  velin-accordion details[open] > summary::after {
+    transform: rotate(225deg);
+  }
+  velin-accordion details > :not(summary) {
     padding: var(--velin-space-4, 1rem) var(--velin-space-5, 1.25rem);
-    background: var(--velin-color-bg-subtle, #f8fafc);
+    background: var(--velin-color-surface-dim, var(--velin-color-bg-subtle, #f8fafc));
     color: var(--velin-color-text-muted, #64748b);
     font-size: var(--velin-text-sm, 0.875rem);
     line-height: 1.6;
     border-block-start: 1px solid var(--velin-color-border, #e2e8f0);
   }
+`;
+      shadowStyles = `
+  :host {
+    display: block;
+  }
 `;
       VelinAccordion = class extends HTMLElement {
         constructor() {
           super();
           this.attachShadow({ mode: "open" });
           this._onToggle = this._onToggle.bind(this);
+          this._onKeydown = this._onKeydown.bind(this);
         }
         connectedCallback() {
+          ensureLightStyles();
           this.shadowRoot.innerHTML = `
-      <style>${styles3}</style>
+      <style>${shadowStyles}</style>
       <slot></slot>
     `;
           this._exclusive = this.hasAttribute("exclusive");
           this._wireDetails();
           this.addEventListener("toggle", this._onToggle, true);
-          this.addEventListener("keydown", this._onKeydown.bind(this));
+          this.addEventListener("keydown", this._onKeydown);
         }
         _wireDetails() {
           let panelIndex = 0;
@@ -1820,13 +2243,21 @@
             if (panel && !panel.id) panel.id = panelId;
             if (summary && panel) {
               summary.setAttribute("aria-controls", panelId);
+              summary.setAttribute("aria-expanded", details.open ? "true" : "false");
+            }
+            if (summary && !summary.hasAttribute("tabindex")) {
+              summary.setAttribute("tabindex", "0");
             }
           }
         }
         _onToggle(event) {
-          if (!this._exclusive) return;
           const openedDetail = event.target;
-          if (!openedDetail.open) return;
+          if (!(openedDetail instanceof HTMLDetailsElement)) return;
+          const summary = openedDetail.querySelector("summary");
+          if (summary) {
+            summary.setAttribute("aria-expanded", openedDetail.open ? "true" : "false");
+          }
+          if (!this._exclusive || !openedDetail.open) return;
           const details = [...this.querySelectorAll("details")];
           details.forEach((d) => {
             if (d !== openedDetail && d.open) {
@@ -1856,6 +2287,9 @@
               event.preventDefault();
               nextIndex = summaries.length - 1;
               break;
+            case "Enter":
+            case " ":
+              return;
             default:
               return;
           }
@@ -1863,6 +2297,7 @@
         }
         disconnectedCallback() {
           this.removeEventListener("toggle", this._onToggle, true);
+          this.removeEventListener("keydown", this._onKeydown);
         }
       };
       customElements.define("velin-accordion", VelinAccordion);
@@ -1875,11 +2310,11 @@
   __export(velin_tabs_exports, {
     default: () => velin_tabs_default
   });
-  var styles4, VelinTabs, velin_tabs_default;
+  var styles3, VelinTabs, velin_tabs_default;
   var init_velin_tabs = __esm({
     "components/velin-tabs.js"() {
       init_focus_manager();
-      styles4 = `
+      styles3 = `
   :host {
     display: block;
   }
@@ -1931,7 +2366,7 @@
         }
         connectedCallback() {
           this.shadowRoot.innerHTML = `
-      <style>${styles4}</style>
+      <style>${styles3}</style>
       <div class="tablist" role="tablist" part="tablist">
         <slot name="tab"></slot>
       </div>
@@ -2017,11 +2452,11 @@
   __export(velin_toast_exports, {
     default: () => velin_toast_default
   });
-  var styles5, VelinToast, velin_toast_default;
+  var styles4, VelinToast, velin_toast_default;
   var init_velin_toast = __esm({
     "components/velin-toast.js"() {
       init_sanitize();
-      styles5 = `
+      styles4 = `
   :host {
     position: fixed;
     z-index: var(--velin-z-toast, 600);
@@ -2091,7 +2526,7 @@
           this._container = null;
         }
         connectedCallback() {
-          this.shadowRoot.innerHTML = `<style>${styles5}</style>`;
+          this.shadowRoot.innerHTML = `<style>${styles4}</style>`;
           this._container = this.shadowRoot;
           this.setAttribute("role", "status");
           this.setAttribute("aria-live", "polite");
@@ -2139,7 +2574,18 @@
     if (variant && variants?.[variant]) return variants[variant];
     return PROVIDER_CDNS[provider];
   }
-  var PROVIDER_CDNS, PROVIDER_VARIANTS, _svgCache, VelinIcon, velin_icon_default;
+  function resolveDefaultSpriteUrl() {
+    if (typeof document !== "undefined") {
+      const meta = document.querySelector('meta[name="velin-icon-sprite"]');
+      const fromMeta = meta?.getAttribute("content")?.trim();
+      if (fromMeta) return fromMeta;
+      const fromHtml = document.documentElement?.getAttribute("data-velin-icon-sprite")?.trim();
+      if (fromHtml) return fromHtml;
+    }
+    const configured = typeof VelinIcon.defaultSprite === "string" ? VelinIcon.defaultSprite.trim() : "";
+    return configured || DEFAULT_SPRITE;
+  }
+  var PROVIDER_CDNS, PROVIDER_VARIANTS, _svgCache, DEFAULT_SPRITE, VelinIcon, velin_icon_default;
   var init_velin_icon = __esm({
     "components/velin-icon.js"() {
       init_sanitize();
@@ -2163,7 +2609,10 @@
         }
       };
       _svgCache = /* @__PURE__ */ new Map();
+      DEFAULT_SPRITE = "velin-icons.svg";
       VelinIcon = class extends HTMLElement {
+        /** @type {string} Relative or absolute sprite URL used when `sprite` attribute is omitted. */
+        static defaultSprite = DEFAULT_SPRITE;
         static get observedAttributes() {
           return ["name", "size", "label", "provider", "variant", "sprite"];
         }
@@ -2219,7 +2668,8 @@
           if (spriteAttr === "" || spriteAttr == null && isLocalSymbol) {
             href = `#${name}`;
           } else {
-            const spriteUrl = sanitizeURL(spriteAttr || "/dist/velin-icons.svg") || "/dist/velin-icons.svg";
+            const fallback = resolveDefaultSpriteUrl();
+            const spriteUrl = sanitizeURL(spriteAttr || fallback) || fallback || DEFAULT_SPRITE;
             href = `${spriteUrl}#${name}`;
           }
           use.setAttribute("href", href);
@@ -2328,12 +2778,12 @@
   __export(velin_drawer_exports, {
     default: () => velin_drawer_default
   });
-  var styles6, VelinDrawer, velin_drawer_default;
+  var styles5, VelinDrawer, velin_drawer_default;
   var init_velin_drawer = __esm({
     "components/velin-drawer.js"() {
       init_focus_manager();
       init_sanitize();
-      styles6 = `
+      styles5 = `
   :host { display: contents; }
   .overlay {
     position: fixed;
@@ -2394,7 +2844,7 @@
           const safeTitle = escapeHTML(title);
           const titleId = "velin-drawer-title";
           this.shadowRoot.innerHTML = `
-      <style>${styles6}</style>
+      <style>${styles5}</style>
       <div class="overlay" part="overlay"></div>
       <div class="drawer" role="dialog" aria-modal="true" aria-labelledby="${titleId}" part="drawer">
         <div class="header" part="header">
@@ -2421,7 +2871,6 @@
           this._prev = saveFocus();
           setBackgroundInert(this);
           document.addEventListener("keydown", this._onKey);
-          document.body.style.overflow = "hidden";
           requestAnimationFrame(() => {
             const f = getFocusableElements(this.shadowRoot);
             if (f.length) f[0].focus();
@@ -2429,8 +2878,7 @@
         }
         _close() {
           document.removeEventListener("keydown", this._onKey);
-          document.body.style.overflow = "";
-          clearBackgroundInert();
+          clearBackgroundInert(this);
           restoreFocus(this._prev);
         }
         _onKey(e) {
@@ -2442,7 +2890,7 @@
         }
         disconnectedCallback() {
           document.removeEventListener("keydown", this._onKey);
-          document.body.style.overflow = "";
+          clearBackgroundInert(this);
         }
       };
       customElements.define("velin-drawer", VelinDrawer);
@@ -2470,7 +2918,7 @@
     document.head.appendChild(link);
     loadedThemeStylesheets.add(slug);
   }
-  var THEMES, BUILTIN_THEMES, loadedThemeStylesheets, styles7, VelinThemeToggle, velin_theme_toggle_default;
+  var THEMES, BUILTIN_THEMES, loadedThemeStylesheets, styles6, VelinThemeToggle, velin_theme_toggle_default;
   var init_velin_theme_toggle = __esm({
     "components/velin-theme-toggle.js"() {
       THEMES = [
@@ -2492,7 +2940,7 @@
       ];
       BUILTIN_THEMES = /* @__PURE__ */ new Set(["", "dark"]);
       loadedThemeStylesheets = /* @__PURE__ */ new Set();
-      styles7 = `
+      styles6 = `
   :host { display: inline-flex; position: relative; }
   .group {
     display: inline-flex; align-items: stretch;
@@ -2581,7 +3029,7 @@
         }
         connectedCallback() {
           this.shadowRoot.innerHTML = `
-      <style>${styles7}</style>
+      <style>${styles6}</style>
       <div class="group" part="group">
         <button class="toggle" part="button" aria-label="Toggle dark mode" aria-pressed="false">
           <svg class="sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true" focusable="false">
@@ -2753,12 +3201,12 @@
   __export(velin_popover_exports, {
     default: () => velin_popover_default
   });
-  var styles8, popoverId, VelinPopover, velin_popover_default;
+  var styles7, popoverId, VelinPopover, velin_popover_default;
   var init_velin_popover = __esm({
     "components/velin-popover.js"() {
       init_sanitize();
       init_focus_manager();
-      styles8 = `
+      styles7 = `
   :host { position: relative; display: inline-block; }
   .popover {
     position: absolute; z-index: var(--velin-z-dropdown, 200);
@@ -2806,7 +3254,7 @@
           this._isDialog = role === "dialog";
           const titleId = title ? `${this._popoverId}-title` : "";
           this.shadowRoot.innerHTML = `
-      <style>${styles8}</style>
+      <style>${styles7}</style>
       <slot name="trigger"></slot>
       <div class="popover popover--${placement}" id="${this._popoverId}" role="${role}" part="popover"${titleId ? ` aria-labelledby="${titleId}"` : ""}>
         ${title ? `<div class="popover__title" id="${titleId}" part="title">${escapeHTML(title)}</div>` : ""}
@@ -2924,11 +3372,11 @@
   __export(velin_copy_exports, {
     default: () => velin_copy_default
   });
-  var styles9, VelinCopy, velin_copy_default;
+  var styles8, VelinCopy, velin_copy_default;
   var init_velin_copy = __esm({
     "components/velin-copy.js"() {
       init_sanitize();
-      styles9 = `
+      styles8 = `
   :host { display: inline-flex; }
   button {
     display: inline-flex; align-items: center; justify-content: center; gap: 0.375rem;
@@ -2957,7 +3405,7 @@
         connectedCallback() {
           const label = escapeHTML(this.getAttribute("label") || "");
           this.shadowRoot.innerHTML = `
-      <style>${styles9}</style>
+      <style>${styles8}</style>
       <button part="button" aria-label="Copy">
         <svg class="copy-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
           <rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 01-2-2V4a2 2 0 012-2h9a2 2 0 012 2v1"/>
@@ -3009,10 +3457,10 @@
   __export(velin_scroll_top_exports, {
     default: () => velin_scroll_top_default
   });
-  var styles10, VelinScrollTop, velin_scroll_top_default;
+  var styles9, VelinScrollTop, velin_scroll_top_default;
   var init_velin_scroll_top = __esm({
     "components/velin-scroll-top.js"() {
-      styles10 = `
+      styles9 = `
   :host { position: fixed; inset-block-end: var(--velin-scroll-top-bottom, var(--velin-space-4, 1rem)); inset-inline-end: var(--velin-scroll-top-end, var(--velin-space-4, 1rem)); z-index: var(--velin-z-fixed, 300); }
   button {
     display: inline-flex; align-items: center; justify-content: center;
@@ -3039,7 +3487,7 @@
           const threshold = parseInt(this.getAttribute("threshold") || "300", 10);
           this._threshold = threshold;
           this.shadowRoot.innerHTML = `
-      <style>${styles10}</style>
+      <style>${styles9}</style>
       <button part="button" aria-label="Scroll to top">
         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false">
           <line x1="12" y1="19" x2="12" y2="5"/><polyline points="5 12 12 5 19 12"/>
@@ -3074,10 +3522,10 @@
   __export(velin_carousel_exports, {
     default: () => velin_carousel_default
   });
-  var styles11, VelinCarousel, velin_carousel_default;
+  var styles10, VelinCarousel, velin_carousel_default;
   var init_velin_carousel = __esm({
     "components/velin-carousel.js"() {
-      styles11 = `
+      styles10 = `
   :host { display: block; position: relative; overflow: hidden; }
   .track {
     display: flex; transition: transform 400ms ease;
@@ -3143,7 +3591,7 @@
         }
         connectedCallback() {
           this.shadowRoot.innerHTML = `
-      <style>${styles11}</style>
+      <style>${styles10}</style>
       <div class="track" role="group" aria-roledescription="carousel" part="track"><slot></slot></div>
       <div class="controls" part="controls">
         <button class="prev" aria-label="Previous slide" part="prev">
@@ -3298,10 +3746,10 @@
     const tag = el.tagName;
     return tag === "BUTTON" || tag === "A" && el.hasAttribute("href") || el.getAttribute("role") === "button";
   }
-  var styles12, collapseId, VelinCollapse, velin_collapse_default;
+  var styles11, collapseId, VelinCollapse, velin_collapse_default;
   var init_velin_collapse = __esm({
     "components/velin-collapse.js"() {
-      styles12 = `
+      styles11 = `
   :host { display: block; }
   .content {
     overflow: hidden;
@@ -3326,7 +3774,7 @@
         }
         connectedCallback() {
           const panelId = this._contentId;
-          this.shadowRoot.innerHTML = "<style>" + styles12 + '</style><slot name="trigger"></slot><div class="content" id="' + panelId + '" part="content"><div class="inner"><slot></slot></div></div>';
+          this.shadowRoot.innerHTML = "<style>" + styles11 + '</style><slot name="trigger"></slot><div class="content" id="' + panelId + '" part="content"><div class="inner"><slot></slot></div></div>';
           const triggerSlot = this.shadowRoot.querySelector('slot[name="trigger"]');
           triggerSlot.addEventListener("slotchange", () => this._wireTrigger());
           this._wireTrigger();
@@ -3440,11 +3888,11 @@
     VelinTooltipWC: () => VelinTooltipWC,
     default: () => velin_tooltip_default
   });
-  var styles13, tooltipId, VelinTooltip, VelinTooltipWC, velin_tooltip_default;
+  var styles12, tooltipId, VelinTooltip, VelinTooltipWC, velin_tooltip_default;
   var init_velin_tooltip = __esm({
     "components/velin-tooltip.js"() {
       init_sanitize();
-      styles13 = `
+      styles12 = `
   :host { position: relative; display: inline-block; }
   .tip {
     position: absolute; z-index: var(--velin-z-tooltip, 700);
@@ -3478,7 +3926,7 @@
           const placement = this.getAttribute("placement") || "top";
           const D = "div";
           this.shadowRoot.innerHTML = `
-      <style>${styles13}</style>
+      <style>${styles12}</style>
       <slot></slot>
       <${D} class="tip" id="${this._tipId}" role="tooltip" data-placement="${escapeHTML(placement)}" part="tip">${escapeHTML(this.getAttribute("content") || "")}</${D}>
     `;
@@ -3610,13 +4058,13 @@
   __export(velin_lightbox_exports, {
     default: () => velin_lightbox_default
   });
-  var styles14, VelinLightbox, velin_lightbox_default;
+  var styles13, VelinLightbox, velin_lightbox_default;
   var init_velin_lightbox = __esm({
     "components/velin-lightbox.js"() {
       init_focus_manager();
       init_a11y_utils();
       init_sanitize();
-      styles14 = `
+      styles13 = `
   :host { display: contents; }
   .overlay {
     position: fixed; inset: 0; z-index: var(--velin-z-modal, 500);
@@ -3669,7 +4117,7 @@
         }
         connectedCallback() {
           this.shadowRoot.innerHTML = `
-      <style>${styles14}</style>
+      <style>${styles13}</style>
       <slot></slot>
       <div class="overlay" role="dialog" aria-modal="true" aria-label="Image lightbox" aria-roledescription="lightbox" part="overlay">
         <button class="nav nav--prev" aria-label="Previous">&#8249;</button>
@@ -3705,7 +4153,6 @@
           this.setAttribute("open", "");
           setBackgroundInert(this);
           this._render();
-          document.body.style.overflow = "hidden";
           const overlay = this.shadowRoot.querySelector(".overlay");
           overlay.removeEventListener("keydown", this._onTrapKey);
           overlay.addEventListener("keydown", this._onTrapKey);
@@ -3713,14 +4160,16 @@
         }
         close() {
           this.removeAttribute("open");
-          clearBackgroundInert();
-          document.body.style.overflow = "";
+          clearBackgroundInert(this);
           if (this._previousFocus) {
             this._previousFocus.focus();
             this._previousFocus = null;
           }
           this.dispatchEvent(new CustomEvent("velin-close", { bubbles: true }));
         }
+        disconnectedCallback() {
+          clearBackgroundInert(this);
+        }
         _prev() {
           this._index = (this._index - 1 + this._items.length) % this._items.length;
           this._render();
@@ -3758,11 +4207,11 @@
     VelinStepperWC: () => VelinStepperWC,
     default: () => velin_stepper_default
   });
-  var styles15, VelinStepper, VelinStepperWC, velin_stepper_default;
+  var styles14, VelinStepper, VelinStepperWC, velin_stepper_default;
   var init_velin_stepper = __esm({
     "components/velin-stepper.js"() {
       init_sanitize();
-      styles15 = `
+      styles14 = `
   :host { display: block; }
   .steps {
     display: flex; gap: var(--velin-space-2, 0.5rem);
@@ -3841,7 +4290,7 @@
             return `<div class="step ${state}" role="listitem" aria-label="${escapeHTML(itemLabel)}"${ariaCurrent}><span class="step__marker">${marker}</span><span class="step__label">${escapeHTML(label)}</span></div>`;
           }).join("");
           this.shadowRoot.innerHTML = `
-      <style>${styles15}</style>
+      <style>${styles14}</style>
       <div class="steps" role="list" aria-label="${escapeHTML(listLabel)}" part="steps">${stepsHTML}</div>
       <div class="panels" part="panels"><slot></slot></div>
     `;
@@ -3908,11 +4357,11 @@
   __export(velin_dialog_exports, {
     default: () => velin_dialog_default
   });
-  var styles16, VelinDialog, velin_dialog_default;
+  var styles15, VelinDialog, velin_dialog_default;
   var init_velin_dialog = __esm({
     "components/velin-dialog.js"() {
       init_sanitize();
-      styles16 = `
+      styles15 = `
   :host { display: contents; }
   dialog {
     border: none; border-radius: var(--velin-radius-lg, 0.75rem);
@@ -3978,7 +4427,7 @@
           this._previousFocus = null;
         }
         connectedCallback() {
-          this.shadowRoot.innerHTML = `<style>${styles16}</style><dialog part="dialog"></dialog>`;
+          this.shadowRoot.innerHTML = `<style>${styles15}</style><dialog part="dialog"></dialog>`;
           const dialog = this.shadowRoot.querySelector("dialog");
           if (dialog) {
             dialog.setAttribute("aria-label", this.getAttribute("aria-label") || "Dialog");
@@ -4051,7 +4500,9 @@
           }
           this._resolve(value);
           this._resolve = null;
-          this.dispatchEvent(new CustomEvent("velin-dialog-close", { bubbles: true, detail: { value } }));
+          const detail = { value };
+          this.dispatchEvent(new CustomEvent("velin-close", { bubbles: true, detail }));
+          this.dispatchEvent(new CustomEvent("velin-dialog-close", { bubbles: true, detail }));
         }
       };
       customElements.define("velin-dialog", VelinDialog);
@@ -4064,11 +4515,11 @@
   __export(velin_countdown_exports, {
     default: () => velin_countdown_default
   });
-  var styles17, VelinCountdown, velin_countdown_default;
+  var styles16, VelinCountdown, velin_countdown_default;
   var init_velin_countdown = __esm({
     "components/velin-countdown.js"() {
       init_sanitize();
-      styles17 = `
+      styles16 = `
   :host { display: inline-flex; font-variant-numeric: tabular-nums; }
   .wrap { display: inline-flex; gap: var(--velin-space-3, 0.75rem); align-items: flex-start; }
   .segment {
@@ -4109,7 +4560,7 @@
           this._timer = null;
         }
         connectedCallback() {
-          this.shadowRoot.innerHTML = `<style>${styles17}</style><div class="wrap"></div>`;
+          this.shadowRoot.innerHTML = `<style>${styles16}</style><div class="wrap"></div>`;
           this._wrap = this.shadowRoot.querySelector(".wrap");
           this.setAttribute("role", "timer");
           this.setAttribute("aria-live", "polite");
@@ -4169,10 +4620,10 @@
   __export(velin_progress_ring_exports, {
     default: () => velin_progress_ring_default
   });
-  var styles18, VelinProgressRing, velin_progress_ring_default;
+  var styles17, VelinProgressRing, velin_progress_ring_default;
   var init_velin_progress_ring = __esm({
     "components/velin-progress-ring.js"() {
-      styles18 = `
+      styles17 = `
   :host { display: inline-flex; align-items: center; justify-content: center; }
   svg { transform: rotate(-90deg); }
   .track { fill: none; stroke: var(--velin-color-border, #e5e5e5); }
@@ -4213,7 +4664,7 @@
           const colorStyle = color ? `stroke: var(--velin-color-${color}, ${color});` : "";
           const showLabel = this.getAttribute("label") !== "false";
           this.shadowRoot.innerHTML = `
-      <style>${styles18}</style>
+      <style>${styles17}</style>
       <svg width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" part="svg" role="progressbar" aria-valuenow="${value}" aria-valuemin="0" aria-valuemax="100">
         <circle class="track" cx="${size / 2}" cy="${size / 2}" r="${radius}" stroke-width="${strokeWidth}" />
         <circle class="fill" cx="${size / 2}" cy="${size / 2}" r="${radius}" stroke-width="${strokeWidth}"
@@ -4359,12 +4810,12 @@
   __export(velin_combobox_exports, {
     default: () => velin_combobox_default
   });
-  var styles19, VelinCombobox, velin_combobox_default;
+  var styles18, VelinCombobox, velin_combobox_default;
   var init_velin_combobox = __esm({
     "components/velin-combobox.js"() {
       init_focus_manager();
       init_sanitize();
-      styles19 = `
+      styles18 = `
   :host { display: inline-block; position: relative; }
   .listbox {
     position: absolute; z-index: var(--velin-z-dropdown, 100);
@@ -4405,7 +4856,7 @@
           this._listId = listId;
           const listLabel = escapeHTML(this.getAttribute("aria-label") || "Options");
           this.shadowRoot.innerHTML = `
-      <style>${styles19}</style>
+      <style>${styles18}</style>
       <slot name="trigger"></slot>
       <div class="listbox" id="${listId}" role="listbox" aria-label="${listLabel}" part="listbox"><slot></slot></div>
     `;
@@ -4516,11 +4967,11 @@
   __export(velin_bottom_nav_exports, {
     default: () => velin_bottom_nav_default
   });
-  var styles20, VelinBottomNav, velin_bottom_nav_default;
+  var styles19, VelinBottomNav, velin_bottom_nav_default;
   var init_velin_bottom_nav = __esm({
     "components/velin-bottom-nav.js"() {
       init_sanitize();
-      styles20 = `
+      styles19 = `
   :host { display: block; }
   nav {
     display: flex;
@@ -4560,7 +5011,7 @@
         connectedCallback() {
           const label = escapeHTML(this.getAttribute("aria-label") || "Bottom navigation");
           this.shadowRoot.innerHTML = `
-      <style>${styles20}</style>
+      <style>${styles19}</style>
       <nav role="navigation" aria-label="${label}"><slot></slot></nav>
     `;
           const slot = this.shadowRoot.querySelector("slot");
@@ -4582,6 +5033,16 @@
             }
             if (el.tagName === "A" && !el.getAttribute("href")) {
               el.setAttribute("role", "button");
+              if (!el.hasAttribute("tabindex")) el.setAttribute("tabindex", "0");
+              if (!el._velinBottomNavKey) {
+                el._velinBottomNavKey = (e) => {
+                  if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    el.click();
+                  }
+                };
+                el.addEventListener("keydown", el._velinBottomNavKey);
+              }
             }
           });
         }
@@ -4645,13 +5106,13 @@
   __export(velin_sheet_exports, {
     default: () => velin_sheet_default
   });
-  var styles21, VelinSheet, velin_sheet_default;
+  var styles20, VelinSheet, velin_sheet_default;
   var init_velin_sheet = __esm({
     "components/velin-sheet.js"() {
       init_focus_manager();
       init_sanitize();
       init_shadow_a11y_styles();
-      styles21 = `
+      styles20 = `
   ${SHADOW_A11Y_STYLES}
   :host { display: contents; }
   .overlay {
@@ -4697,7 +5158,7 @@
           const title = escapeHTML(this.getAttribute("title") || this.getAttribute("label") || "");
           const titleId = "velin-sheet-title";
           this.shadowRoot.innerHTML = `
-      <style>${styles21}</style>
+      <style>${styles20}</style>
       <div class="overlay" part="overlay"></div>
       <div class="sheet" role="dialog" aria-modal="true" aria-labelledby="${titleId}" part="sheet">
         <div class="header" part="header">
@@ -4725,7 +5186,6 @@
           this._prev = saveFocus();
           setBackgroundInert(this);
           document.addEventListener("keydown", this._onKey);
-          document.body.style.overflow = "hidden";
           requestAnimationFrame(() => {
             const f = getFocusableElements(this.shadowRoot);
             if (f.length) f[0].focus();
@@ -4733,8 +5193,7 @@
         }
         _close() {
           document.removeEventListener("keydown", this._onKey);
-          document.body.style.overflow = "";
-          clearBackgroundInert();
+          clearBackgroundInert(this);
           restoreFocus(this._prev);
         }
         _onKey(e) {
@@ -4746,7 +5205,7 @@
         }
         disconnectedCallback() {
           document.removeEventListener("keydown", this._onKey);
-          document.body.style.overflow = "";
+          clearBackgroundInert(this);
         }
       };
       customElements.define("velin-sheet", VelinSheet);
@@ -4759,13 +5218,13 @@
   __export(velin_segmented_control_exports, {
     default: () => velin_segmented_control_default
   });
-  var styles22, VelinSegmentedControl, velin_segmented_control_default;
+  var styles21, VelinSegmentedControl, velin_segmented_control_default;
   var init_velin_segmented_control = __esm({
     "components/velin-segmented-control.js"() {
       init_focus_manager();
       init_sanitize();
       init_shadow_a11y_styles();
-      styles22 = `
+      styles21 = `
   ${SHADOW_A11Y_STYLES}
   :host { display: block; }
   .group {
@@ -4803,7 +5262,7 @@
         connectedCallback() {
           const label = escapeHTML(this.getAttribute("aria-label") || "Segmented control");
           this.shadowRoot.innerHTML = `
-      <style>${styles22}</style>
+      <style>${styles21}</style>
       <div class="group" role="group" aria-label="${label}"><slot></slot></div>
     `;
           this.addEventListener("click", this._onClick);
@@ -4868,13 +5327,13 @@
   __export(velin_rating_exports, {
     default: () => velin_rating_default
   });
-  var styles23, MAX, VelinRating, velin_rating_default;
+  var styles22, MAX, VelinRating, velin_rating_default;
   var init_velin_rating = __esm({
     "components/velin-rating.js"() {
       init_focus_manager();
       init_sanitize();
       init_shadow_a11y_styles();
-      styles23 = `
+      styles22 = `
   ${SHADOW_A11Y_STYLES}
   :host { display: inline-block; }
   .stars { display: inline-flex; gap: var(--velin-space-1, 0.25rem); }
@@ -4897,7 +5356,7 @@
           this._onKey = this._onKey.bind(this);
         }
         connectedCallback() {
-          this.shadowRoot.innerHTML = `<style>${styles23}</style><div class="stars" role="radiogroup"></div>`;
+          this.shadowRoot.innerHTML = `<style>${styles22}</style><div class="stars" role="radiogroup"></div>`;
           this._render();
           this.shadowRoot.querySelector(".stars").addEventListener("click", this._onClick);
           this.shadowRoot.querySelector(".stars").addEventListener("keydown", this._onKey);
@@ -4959,13 +5418,13 @@
   __export(velin_menubar_exports, {
     default: () => velin_menubar_default
   });
-  var styles24, VelinMenubar, velin_menubar_default;
+  var styles23, VelinMenubar, velin_menubar_default;
   var init_velin_menubar = __esm({
     "components/velin-menubar.js"() {
       init_focus_manager();
       init_sanitize();
       init_shadow_a11y_styles();
-      styles24 = `
+      styles23 = `
   ${SHADOW_A11Y_STYLES}
   :host { display: block; }
   .menubar {
@@ -5000,7 +5459,7 @@
         connectedCallback() {
           const label = escapeHTML(this.getAttribute("aria-label") || "Menu bar");
           this.shadowRoot.innerHTML = `
-      <style>${styles24}</style>
+      <style>${styles23}</style>
       <div class="menubar" role="menubar" aria-label="${label}"><slot></slot></div>
     `;
           this.addEventListener("keydown", this._onKey);
@@ -5045,13 +5504,13 @@
   __export(velin_command_exports, {
     default: () => velin_command_default
   });
-  var styles25, VelinCommand, velin_command_default;
+  var styles24, VelinCommand, velin_command_default;
   var init_velin_command = __esm({
     "components/velin-command.js"() {
       init_focus_manager();
       init_sanitize();
       init_shadow_a11y_styles();
-      styles25 = `
+      styles24 = `
   ${SHADOW_A11Y_STYLES}
   :host { display: contents; }
   .overlay {
@@ -5060,9 +5519,14 @@
     padding: 10vh var(--velin-space-4, 1rem) var(--velin-space-4, 1rem);
     background: var(--velin-color-overlay, rgba(0,0,0,0.4));
     opacity: 0; visibility: hidden;
+    pointer-events: none;
     transition: opacity 150ms ease, visibility 150ms ease;
   }
-  :host([open]) .overlay { opacity: 1; visibility: visible; }
+  :host([open]) .overlay {
+    opacity: 1;
+    visibility: visible;
+    pointer-events: auto;
+  }
   .panel {
     inline-size: min(32rem, 100%);
     background: var(--velin-color-surface-bright, #fff);
@@ -5105,7 +5569,7 @@
         connectedCallback() {
           const placeholder = escapeHTML(this.getAttribute("placeholder") || "Search commands\u2026");
           this.shadowRoot.innerHTML = `
-      <style>${styles25}</style>
+      <style>${styles24}</style>
       <div class="overlay" part="overlay">
         <div class="panel" role="dialog" aria-modal="true" aria-label="Command palette" part="panel">
           <input class="search" type="search" autocomplete="off" placeholder="${placeholder}" aria-label="Search" part="search" />
@@ -5114,6 +5578,7 @@
       </div>
     `;
           this.shadowRoot.querySelector(".search").addEventListener("input", this._onInput);
+          this.shadowRoot.querySelector(".overlay")?.addEventListener("click", this._onOverlayClick);
           this.shadowRoot.querySelector("slot")?.addEventListener("slotchange", () => this._filter(""));
           this._filter("");
         }
@@ -5127,6 +5592,13 @@
           this.removeAttribute("open");
           this.dispatchEvent(new CustomEvent("velin-close", { bubbles: true }));
         }
+        toggle() {
+          if (this.hasAttribute("open")) this.close();
+          else this.open();
+        }
+        _onOverlayClick = (event) => {
+          if (event.target === event.currentTarget) this.close();
+        };
         _open() {
           this._prev = saveFocus();
           setBackgroundInert(this);
@@ -5138,7 +5610,7 @@
         }
         _close() {
           document.removeEventListener("keydown", this._onKey);
-          clearBackgroundInert();
+          clearBackgroundInert(this);
           restoreFocus(this._prev);
           const input = this.shadowRoot.querySelector(".search");
           if (input) input.value = "";
@@ -5177,6 +5649,8 @@
         }
         disconnectedCallback() {
           document.removeEventListener("keydown", this._onKey);
+          this.shadowRoot?.querySelector(".overlay")?.removeEventListener("click", this._onOverlayClick);
+          if (this.hasAttribute("open")) clearBackgroundInert(this);
         }
       };
       customElements.define("velin-command", VelinCommand);
@@ -5189,17 +5663,17 @@
   __export(velin_announcer_exports, {
     default: () => velin_announcer_default
   });
-  var styles26, VelinAnnouncer, velin_announcer_default;
+  var styles25, VelinAnnouncer, velin_announcer_default;
   var init_velin_announcer = __esm({
     "components/velin-announcer.js"() {
-      styles26 = `
+      styles25 = `
   :host { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; border: 0; }
 `;
       VelinAnnouncer = class extends HTMLElement {
         connectedCallback() {
           if (!this.shadowRoot) this.attachShadow({ mode: "open" });
           const live = this.getAttribute("polite") === "false" ? "assertive" : "polite";
-          this.shadowRoot.innerHTML = "<style>" + styles26 + '</style><div role="status" aria-live="' + live + '" aria-atomic="true" part="region"></div>';
+          this.shadowRoot.innerHTML = "<style>" + styles25 + '</style><div role="status" aria-live="' + live + '" aria-atomic="true" part="region"></div>';
           this._region = this.shadowRoot.querySelector('[role="status"]');
         }
         announce(message, { assertive = false } = {}) {
@@ -5243,11 +5717,11 @@
       return raw;
     }
   }
-  var styles27, VelinEmail, velin_email_default;
+  var styles26, VelinEmail, velin_email_default;
   var init_velin_email = __esm({
     "components/velin-email.js"() {
       init_sanitize();
-      styles27 = `
+      styles26 = `
   :host { display: inline; }
   button {
     font: inherit;
@@ -5294,13 +5768,13 @@
           const safeEmail = escapeHTML(email);
           if (this._revealed) {
             this.shadowRoot.innerHTML = `
-        <style>${styles27}</style>
+        <style>${styles26}</style>
         <span class="revealed" part="email"><a href="mailto:${escapeHTMLAttribute(email)}">${safeEmail}</a></span>
       `;
             return;
           }
           this.shadowRoot.innerHTML = `
-      <style>${styles27}</style>
+      <style>${styles26}</style>
       <button type="button" part="reveal" aria-label="${escapeHTMLAttribute(label)}">${escapeHTML(label)}</button>
     `;
           this.shadowRoot.querySelector("button").addEventListener("click", () => {
@@ -5317,6 +5791,227 @@
     }
   });
 
+  // components/velin-calendar.js
+  var velin_calendar_exports = {};
+  __export(velin_calendar_exports, {
+    default: () => velin_calendar_default
+  });
+  function iso(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+  }
+  function parseISO(v) {
+    if (!v) return null;
+    const m = String(v).match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!m) return null;
+    const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  var styles27, VelinCalendar, velin_calendar_default;
+  var init_velin_calendar = __esm({
+    "components/velin-calendar.js"() {
+      init_sanitize();
+      styles27 = `
+  :host { display: block; max-inline-size: 100%; }
+  .cal {
+    box-sizing: border-box;
+    border: 1px solid var(--velin-color-border, #ddd);
+    border-radius: var(--velin-radius-md, 0.5rem);
+    background: var(--velin-color-surface, #fff);
+    color: var(--velin-color-text, #111);
+    padding: var(--velin-space-3, 0.75rem);
+    max-inline-size: min(20rem, 100%);
+    inline-size: 100%;
+  }
+  .head {
+    display: flex; align-items: center; justify-content: space-between;
+    gap: var(--velin-space-2, 0.5rem); margin-block-end: var(--velin-space-3, 0.75rem);
+  }
+  .title { font-weight: var(--velin-weight-semibold, 600); margin: 0; font-size: var(--velin-text-base, 1rem); }
+  .nav {
+    display: inline-flex; align-items: center; justify-content: center;
+    flex-shrink: 0;
+    min-inline-size: 2.5rem; min-block-size: 2.5rem;
+    border: 1px solid var(--velin-color-border, #ddd);
+    border-radius: var(--velin-radius-sm, 0.25rem);
+    background: var(--velin-color-surface-bright, #fff);
+    color: inherit; cursor: pointer;
+  }
+  .nav:focus-visible { outline: 2px solid var(--velin-color-focus, #2563eb); outline-offset: 2px; }
+  .grid {
+    display: grid; grid-template-columns: repeat(7, minmax(0, 1fr)); gap: 0.25rem;
+  }
+  .dow {
+    text-align: center; font-size: var(--velin-text-xs, 0.75rem);
+    color: var(--velin-color-text-muted, #64748b); padding-block: 0.25rem;
+  }
+  .day {
+    inline-size: 100%;
+    min-inline-size: 0;
+    min-block-size: 2.25rem;
+    aspect-ratio: 1;
+    border: none; border-radius: var(--velin-radius-sm, 0.25rem);
+    background: transparent; color: inherit; cursor: pointer;
+    font: inherit;
+    padding: 0;
+  }
+  .day[aria-disabled="true"] { opacity: 0.35; cursor: not-allowed; }
+  .day[aria-selected="true"] {
+    background: var(--velin-color-primary, #2563eb);
+    color: var(--velin-color-on-primary, #fff);
+  }
+  .day:not([aria-disabled="true"]):hover {
+    background: var(--velin-color-primary-subtle, #eff6ff);
+  }
+  .day:focus-visible { outline: 2px solid var(--velin-color-focus, #2563eb); outline-offset: 1px; }
+  .out { color: var(--velin-color-text-muted, #94a3b8); }
+`;
+      VelinCalendar = class extends HTMLElement {
+        static get observedAttributes() {
+          return ["value", "min", "max", "label"];
+        }
+        constructor() {
+          super();
+          this.attachShadow({ mode: "open" });
+          this._view = /* @__PURE__ */ new Date();
+          this._view.setDate(1);
+          this._onKey = this._onKey.bind(this);
+        }
+        connectedCallback() {
+          const selected = parseISO(this.getAttribute("value")) || /* @__PURE__ */ new Date();
+          this._view = new Date(selected.getFullYear(), selected.getMonth(), 1);
+          this._render();
+        }
+        attributeChangedCallback(name, prev, next) {
+          if (prev === next || !this.shadowRoot?.querySelector(".cal")) return;
+          if (name === "value" && next) {
+            const d = parseISO(next);
+            if (d) this._view = new Date(d.getFullYear(), d.getMonth(), 1);
+          }
+          this._render();
+        }
+        get value() {
+          return this.getAttribute("value") || "";
+        }
+        set value(v) {
+          if (v) this.setAttribute("value", v);
+          else this.removeAttribute("value");
+        }
+        _inRange(d) {
+          const min = parseISO(this.getAttribute("min"));
+          const max = parseISO(this.getAttribute("max"));
+          if (min && d < min) return false;
+          if (max && d > max) return false;
+          return true;
+        }
+        _select(d) {
+          if (!this._inRange(d)) return;
+          const v = iso(d);
+          this.setAttribute("value", v);
+          this.dispatchEvent(new CustomEvent("velin-change", { bubbles: true, detail: { value: v, date: d } }));
+          this._render();
+        }
+        _shiftMonth(delta) {
+          this._view = new Date(this._view.getFullYear(), this._view.getMonth() + delta, 1);
+          this._render();
+        }
+        _onKey(e) {
+          const selected = parseISO(this.getAttribute("value")) || /* @__PURE__ */ new Date();
+          let next = new Date(selected);
+          switch (e.key) {
+            case "ArrowLeft":
+              next.setDate(next.getDate() - 1);
+              break;
+            case "ArrowRight":
+              next.setDate(next.getDate() + 1);
+              break;
+            case "ArrowUp":
+              next.setDate(next.getDate() - 7);
+              break;
+            case "ArrowDown":
+              next.setDate(next.getDate() + 7);
+              break;
+            case "Home":
+              next = new Date(next.getFullYear(), next.getMonth(), 1);
+              break;
+            case "End":
+              next = new Date(next.getFullYear(), next.getMonth() + 1, 0);
+              break;
+            case "PageUp":
+              next = new Date(next.getFullYear(), next.getMonth() - 1, next.getDate());
+              break;
+            case "PageDown":
+              next = new Date(next.getFullYear(), next.getMonth() + 1, next.getDate());
+              break;
+            case "Enter":
+            case " ":
+              e.preventDefault();
+              this._select(selected);
+              return;
+            default:
+              return;
+          }
+          e.preventDefault();
+          if (!this._inRange(next)) return;
+          this._view = new Date(next.getFullYear(), next.getMonth(), 1);
+          this.setAttribute("value", iso(next));
+          this.dispatchEvent(new CustomEvent("velin-change", { bubbles: true, detail: { value: iso(next), date: next } }));
+          this._render();
+          this.shadowRoot.querySelector(`[data-iso="${iso(next)}"]`)?.focus();
+        }
+        _render() {
+          const label = escapeHTML(this.getAttribute("label") || "Choose date");
+          const selected = parseISO(this.getAttribute("value"));
+          const y = this._view.getFullYear();
+          const m = this._view.getMonth();
+          const title = this._view.toLocaleString(void 0, { month: "long", year: "numeric" });
+          const start = new Date(y, m, 1);
+          const startDow = (start.getDay() + 6) % 7;
+          const daysInMonth = new Date(y, m + 1, 0).getDate();
+          const dows = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+          let cells = dows.map((d) => `<div class="dow" aria-hidden="true">${d}</div>`).join("");
+          for (let i = 0; i < startDow; i += 1) {
+            const d = new Date(y, m, -startDow + i + 1);
+            cells += `<button type="button" class="day out" tabindex="-1" data-iso="${iso(d)}" aria-label="${iso(d)}">${d.getDate()}</button>`;
+          }
+          for (let day = 1; day <= daysInMonth; day += 1) {
+            const d = new Date(y, m, day);
+            const id = iso(d);
+            const sel = selected && iso(selected) === id;
+            const disabled = !this._inRange(d);
+            cells += `<button type="button" class="day" data-iso="${id}" aria-label="${id}" aria-selected="${sel ? "true" : "false"}" aria-disabled="${disabled ? "true" : "false"}" tabindex="${sel ? "0" : "-1"}">${day}</button>`;
+          }
+          this.shadowRoot.innerHTML = `
+      <style>${styles27}</style>
+      <div class="cal" role="group" aria-label="${label}">
+        <div class="head">
+          <button type="button" class="nav" data-nav="-1" aria-label="Previous month">\u2039</button>
+          <p class="title" id="cal-title">${escapeHTML(title)}</p>
+          <button type="button" class="nav" data-nav="1" aria-label="Next month">\u203A</button>
+        </div>
+        <div class="grid" role="grid" aria-labelledby="cal-title">${cells}</div>
+      </div>
+    `;
+          this.shadowRoot.querySelectorAll("[data-nav]").forEach((btn) => {
+            btn.addEventListener("click", () => this._shiftMonth(Number(btn.getAttribute("data-nav"))));
+          });
+          this.shadowRoot.querySelectorAll(".day").forEach((btn) => {
+            btn.addEventListener("click", () => {
+              if (btn.getAttribute("aria-disabled") === "true") return;
+              const d = parseISO(btn.getAttribute("data-iso"));
+              if (d) this._select(d);
+            });
+            btn.addEventListener("keydown", this._onKey);
+          });
+        }
+      };
+      customElements.define("velin-calendar", VelinCalendar);
+      velin_calendar_default = VelinCalendar;
+    }
+  });
+
   // core/highlight/languages/_utils.js
   function tokenize(code, rules) {
     const tokens = [];
@@ -5706,6 +6401,146 @@
     }
   });
 
+  // core/highlight/languages/python.js
+  var python_exports = {};
+  __export(python_exports, {
+    default: () => lexPython
+  });
+  function lexPython(code) {
+    return tokenize(code, RULES9);
+  }
+  var RULES9;
+  var init_python = __esm({
+    "core/highlight/languages/python.js"() {
+      init_utils();
+      RULES9 = [
+        { type: "comment", re: /#[^\n]*/y },
+        // Triple-quoted strings first so the single-quote rules cannot split them.
+        { type: "string", re: /[rbfu]{0,2}"""[\s\S]*?"""/y },
+        { type: "string", re: /[rbfu]{0,2}'''[\s\S]*?'''/y },
+        { type: "string", re: /[rbfu]{0,2}"(?:\\.|[^"\\\n])*"/y },
+        { type: "string", re: /[rbfu]{0,2}'(?:\\.|[^'\\\n])*'/y },
+        { type: "number", re: /\b0[xX][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?j?\b/y },
+        {
+          type: "keyword",
+          re: /\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b/y
+        },
+        {
+          type: "builtin",
+          re: /\b(?:None|True|False|self|cls|abs|all|any|bool|bytes|dict|dir|enumerate|filter|float|format|frozenset|getattr|hasattr|int|isinstance|issubclass|iter|len|list|map|max|min|next|object|open|print|range|repr|reversed|round|set|setattr|sorted|str|sum|super|tuple|type|zip)\b/y
+        },
+        // Multi-character operators first so `->` is not split into `-` and `>`.
+        { type: "operator", re: /->|:=|\*\*=?|\/\/=?|<<=?|>>=?|[-+*/%&|^~<>!=]=?/y },
+        { type: "punctuation", re: /[[\]{}(),:;.@]/y },
+        { type: "identifier", re: /\b[A-Za-z_]\w*\b/y }
+      ];
+    }
+  });
+
+  // core/highlight/languages/yaml.js
+  var yaml_exports = {};
+  __export(yaml_exports, {
+    default: () => lexYaml
+  });
+  function lexYaml(code) {
+    return tokenize(code, RULES10);
+  }
+  var RULES10;
+  var init_yaml = __esm({
+    "core/highlight/languages/yaml.js"() {
+      init_utils();
+      RULES10 = [
+        { type: "comment", re: /#[^\n]*/y },
+        // Document markers and block scalar indicators.
+        { type: "punctuation", re: /^(?:---|\.\.\.)$/my },
+        { type: "string", re: /"(?:\\.|[^"\\])*"/y },
+        { type: "string", re: /'(?:''|[^'])*'/y },
+        // Keys are the primary structure in YAML, so they get the attr-name colour.
+        { type: "attr-name", re: /^[ \t]*-?[ \t]*[\w.$-]+(?=[ \t]*:(?:[ \t]|$))/my },
+        { type: "punctuation", re: /^[ \t]*-(?=[ \t]|$)/my },
+        { type: "keyword", re: /\b(?:true|false|null|yes|no|on|off|~)\b/yi },
+        { type: "number", re: /\b-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b/y },
+        // Anchors, aliases, tags and block scalar headers.
+        { type: "operator", re: /[&*]\w+|![\w/!-]*|[|>][+-]?\d*(?=\s*$)/my },
+        { type: "punctuation", re: /[:,[\]{}]/y }
+      ];
+    }
+  });
+
+  // core/highlight/languages/go.js
+  var go_exports = {};
+  __export(go_exports, {
+    default: () => lexGo
+  });
+  function lexGo(code) {
+    return tokenize(code, RULES11);
+  }
+  var RULES11;
+  var init_go = __esm({
+    "core/highlight/languages/go.js"() {
+      init_utils();
+      RULES11 = [
+        { type: "comment", re: /\/\/[^\n]*/y },
+        { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+        // Raw strings may span lines.
+        { type: "string", re: /`[^`]*`/y },
+        { type: "string", re: /"(?:\\.|[^"\\\n])*"/y },
+        { type: "string", re: /'(?:\\.|[^'\\\n])*'/y },
+        { type: "number", re: /\b0[xX][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]*)?(?:[eE][+-]?\d+)?i?\b/y },
+        {
+          type: "keyword",
+          re: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go|goto|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/y
+        },
+        {
+          type: "builtin",
+          re: /\b(?:append|bool|byte|cap|clear|close|complex|complex64|complex128|copy|delete|error|float32|float64|imag|int|int8|int16|int32|int64|len|make|max|min|new|nil|panic|print|println|real|recover|rune|string|true|false|iota|uint|uint8|uint16|uint32|uint64|uintptr|any)\b/y
+        },
+        { type: "operator", re: /:=|\.\.\.|&&|\|\||<-|\+\+|--|<<=?|>>=?|&\^=?|[-+*/%&|^<>!=]=?|~/y },
+        { type: "punctuation", re: /[[\]{}(),;:.]/y },
+        { type: "identifier", re: /\b[A-Za-z_]\w*\b/y }
+      ];
+    }
+  });
+
+  // core/highlight/languages/rust.js
+  var rust_exports = {};
+  __export(rust_exports, {
+    default: () => lexRust
+  });
+  function lexRust(code) {
+    return tokenize(code, RULES12);
+  }
+  var RULES12;
+  var init_rust = __esm({
+    "core/highlight/languages/rust.js"() {
+      init_utils();
+      RULES12 = [
+        { type: "comment", re: /\/\/\/?[^\n]*/y },
+        { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+        // Raw strings close on the same number of hashes they opened with.
+        { type: "string", re: /b?r(#*)"[\s\S]*?"\1/y },
+        { type: "string", re: /b?"(?:\\.|[^"\\])*"/y },
+        { type: "string", re: /b?'(?:\\.|[^'\\])'/y },
+        // Attributes such as #[derive(Debug)] read as annotations.
+        { type: "builtin", re: /#!?\[[^\]]*\]/y },
+        { type: "number", re: /\b0[xXbo][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?(?:[iuf](?:8|16|32|64|128|size))?\b/y },
+        {
+          type: "keyword",
+          re: /\b(?:as|async|await|break|const|continue|crate|dyn|else|enum|extern|fn|for|if|impl|in|let|loop|match|mod|move|mut|pub|ref|return|self|Self|static|struct|super|trait|type|unsafe|use|where|while)\b/y
+        },
+        {
+          type: "builtin",
+          re: /\b(?:bool|char|f32|f64|i8|i16|i32|i64|i128|isize|str|u8|u16|u32|u64|u128|usize|String|Vec|Option|Result|Some|None|Ok|Err|Box|Rc|Arc|true|false)\b/y
+        },
+        // Lifetimes such as 'a must not be read as an unterminated char literal.
+        { type: "operator", re: /'[a-z_]\w*\b/y },
+        { type: "operator", re: /=>|->|::|\.\.=?|&&|\|\||<<=?|>>=?|[-+*/%&|^<>!=]=?|[?@]/y },
+        { type: "punctuation", re: /[[\]{}(),;:.#]/y },
+        { type: "identifier", re: /\b[A-Za-z_]\w*!?\b/y }
+      ];
+    }
+  });
+
   // core/highlight/registry.js
   function normalizeLanguage(name) {
     const n = (name || "").trim().toLowerCase();
@@ -5725,11 +6560,14 @@
       md: "markdown",
       plaintext: "text",
       "plain-text": "text",
-      yml: "text",
-      yaml: "text",
+      yml: "yaml",
       toml: "text",
       ini: "text",
-      php8: "php"
+      php8: "php",
+      py: "python",
+      python3: "python",
+      golang: "go",
+      rs: "rust"
     };
     return map[n] || n;
   }
@@ -5785,7 +6623,15 @@
         markup: () => Promise.resolve().then(() => (init_html(), html_exports)),
         console: () => Promise.resolve().then(() => (init_plain(), plain_exports)),
         php: () => Promise.resolve().then(() => (init_php(), php_exports)),
-        blade: () => Promise.resolve().then(() => (init_blade(), blade_exports))
+        blade: () => Promise.resolve().then(() => (init_blade(), blade_exports)),
+        python: () => Promise.resolve().then(() => (init_python(), python_exports)),
+        py: () => Promise.resolve().then(() => (init_python(), python_exports)),
+        yaml: () => Promise.resolve().then(() => (init_yaml(), yaml_exports)),
+        yml: () => Promise.resolve().then(() => (init_yaml(), yaml_exports)),
+        go: () => Promise.resolve().then(() => (init_go(), go_exports)),
+        golang: () => Promise.resolve().then(() => (init_go(), go_exports)),
+        rust: () => Promise.resolve().then(() => (init_rust(), rust_exports)),
+        rs: () => Promise.resolve().then(() => (init_rust(), rust_exports))
       };
       registerLanguage("js", lexJs);
     }
@@ -6308,12 +7154,823 @@
     }
   });
 
+  // components/velin-data-table.js
+  var velin_data_table_exports = {};
+  __export(velin_data_table_exports, {
+    default: () => velin_data_table_default
+  });
+  function sortValue(cell, type) {
+    const raw = cell?.dataset?.sortValue ?? cell?.textContent ?? "";
+    const text2 = raw.trim();
+    if (type === "number") {
+      const num = Number.parseFloat(text2.replace(/[^\d.,-]/g, "").replace(",", "."));
+      return Number.isNaN(num) ? Number.NEGATIVE_INFINITY : num;
+    }
+    if (type === "date") {
+      const time = Date.parse(text2);
+      return Number.isNaN(time) ? Number.NEGATIVE_INFINITY : time;
+    }
+    return text2.toLowerCase();
+  }
+  var SORT_TYPES, warnedMissingName, VelinDataTable, velin_data_table_default;
+  var init_velin_data_table = __esm({
+    "components/velin-data-table.js"() {
+      init_a11y_utils();
+      SORT_TYPES = /* @__PURE__ */ new Set(["text", "number", "date"]);
+      warnedMissingName = false;
+      VelinDataTable = class extends HTMLElement {
+        static get observedAttributes() {
+          return ["page-size", "filter-input", "empty-text", "label", "editable"];
+        }
+        constructor() {
+          super();
+          this._table = null;
+          this._page = 1;
+          this._query = "";
+          this._sortIndex = -1;
+          this._sortDirection = "ascending";
+          this._filterEl = null;
+          this._pagination = null;
+          this._emptyRow = null;
+          this._filterTimer = null;
+          this._onFilterInput = this._onFilterInput.bind(this);
+        }
+        connectedCallback() {
+          this.classList.add("velin-data-table");
+          requestAnimationFrame(() => this._init());
+        }
+        disconnectedCallback() {
+          if (this._filterEl) this._filterEl.removeEventListener("input", this._onFilterInput);
+          if (this._filterTimer) clearTimeout(this._filterTimer);
+        }
+        attributeChangedCallback(name, previous, next) {
+          if (previous === next || !this._table) return;
+          if (name === "page-size") {
+            this._page = 1;
+            this._render();
+          } else if (name === "filter-input") {
+            this._bindFilterInput();
+          } else if (name === "label") {
+            this._ensureAccessibleName();
+          }
+        }
+        // ── Public API ─────────────────────────────────────────────────────────────
+        /** @returns {HTMLTableRowElement[]} */
+        get rows() {
+          const body = this._table?.tBodies?.[0];
+          return body ? [...body.rows].filter((row) => row !== this._emptyRow) : [];
+        }
+        /** Rows matching the current filter, across all pages. */
+        get matchingRows() {
+          return this.rows.filter((row) => !row.dataset.velinFiltered);
+        }
+        /** Rows visible on the current page. */
+        get visibleRows() {
+          return this.matchingRows.filter((row) => !row.hidden);
+        }
+        get page() {
+          return this._page;
+        }
+        get pageSize() {
+          const size = Number.parseInt(this.getAttribute("page-size") || "", 10);
+          return Number.isFinite(size) && size > 0 ? size : 0;
+        }
+        get pageCount() {
+          const size = this.pageSize;
+          if (!size) return 1;
+          return Math.max(1, Math.ceil(this.matchingRows.length / size));
+        }
+        /**
+         * @param {number} index Column index
+         * @param {'ascending' | 'descending'} [direction]
+         */
+        sort(index, direction) {
+          const headers = this._headers();
+          const header = headers[index];
+          if (!header) return;
+          const type = this._sortType(header);
+          if (type === "none") return;
+          this._sortDirection = direction || (this._sortIndex === index && this._sortDirection === "ascending" ? "descending" : "ascending");
+          this._sortIndex = index;
+          const factor = this._sortDirection === "ascending" ? 1 : -1;
+          const body = this._table.tBodies[0];
+          const sorted = this.rows.slice().sort((a, b) => {
+            const av = sortValue(a.cells[index], type);
+            const bv = sortValue(b.cells[index], type);
+            if (av < bv) return -1 * factor;
+            if (av > bv) return 1 * factor;
+            return 0;
+          });
+          for (const row of sorted) body.appendChild(row);
+          this._syncSortState();
+          this._page = 1;
+          this._render();
+          const label = header.dataset.sortLabel || header.textContent.trim();
+          announce(`${label} sorted ${this._sortDirection}`);
+          this.dispatchEvent(new CustomEvent("velin-data-table-sort", {
+            bubbles: true,
+            detail: { index, direction: this._sortDirection, column: label }
+          }));
+        }
+        /** @param {string} query */
+        filter(query) {
+          this._query = String(query || "").trim().toLowerCase();
+          for (const row of this.rows) {
+            const match = !this._query || this._rowText(row).includes(this._query);
+            if (match) delete row.dataset.velinFiltered;
+            else row.dataset.velinFiltered = "true";
+          }
+          this._page = 1;
+          this._render();
+          const count = this.matchingRows.length;
+          announce(count === 1 ? "1 row matches" : `${count} rows match`);
+          this.dispatchEvent(new CustomEvent("velin-data-table-filter", {
+            bubbles: true,
+            detail: { query: this._query, count }
+          }));
+        }
+        /** @param {number} page */
+        goToPage(page) {
+          const target = Math.min(Math.max(1, Math.trunc(page) || 1), this.pageCount);
+          if (target === this._page) return;
+          this._page = target;
+          this._render();
+          announce(`Page ${this._page} of ${this.pageCount}`);
+          this.dispatchEvent(new CustomEvent("velin-data-table-page", {
+            bubbles: true,
+            detail: { page: this._page, pageCount: this.pageCount }
+          }));
+        }
+        // ── Setup ──────────────────────────────────────────────────────────────────
+        _init() {
+          this._table = this.querySelector("table");
+          if (!this._table || !this._table.tBodies.length) return;
+          this._ensureAccessibleName();
+          this._setupSorting();
+          this._setupEditable();
+          this._bindFilterInput();
+          this._render();
+        }
+        _headers() {
+          const headRow = this._table.tHead?.rows?.[0];
+          return headRow ? [...headRow.cells] : [];
+        }
+        /** @param {HTMLTableCellElement} header */
+        _sortType(header) {
+          const declared = (header.dataset.sort || "").toLowerCase();
+          if (declared === "none") return "none";
+          if (SORT_TYPES.has(declared)) return declared;
+          return this.hasAttribute("sortable") ? "text" : "none";
+        }
+        /**
+         * A table without a name is unusable with a screen reader, so surface it
+         * instead of failing silently (WCAG 1.3.1 / 2.4.6).
+         */
+        _ensureAccessibleName() {
+          const table = this._table;
+          if (!table) return;
+          const label = this.getAttribute("label");
+          const hasName = table.caption?.textContent.trim() || table.getAttribute("aria-label")?.trim() || table.getAttribute("aria-labelledby")?.trim();
+          if (!hasName && label) {
+            table.setAttribute("aria-label", label);
+            return;
+          }
+          if (!hasName && !warnedMissingName) {
+            warnedMissingName = true;
+            console.warn("[velinstyle] <velin-data-table> needs a <caption>, aria-label, or a label attribute.");
+          }
+        }
+        /** Sortable headers get a real button so keyboard and AT support come for free. */
+        _setupSorting() {
+          this._headers().forEach((header, index) => {
+            if (this._sortType(header) === "none") return;
+            if (header.querySelector(".velin-data-table__sort")) return;
+            const label = header.textContent.trim();
+            header.dataset.sortLabel = label;
+            header.setAttribute("aria-sort", "none");
+            header.classList.add("velin-data-table__th");
+            const button = document.createElement("button");
+            button.type = "button";
+            button.className = "velin-data-table__sort";
+            button.textContent = label;
+            const icon = document.createElement("span");
+            icon.className = "velin-data-table__sort-icon";
+            icon.setAttribute("aria-hidden", "true");
+            button.appendChild(icon);
+            button.addEventListener("click", () => this.sort(index));
+            header.textContent = "";
+            header.appendChild(button);
+          });
+        }
+        /**
+         * Inline edit: double-click or Enter on focused cell with data-editable / host editable.
+         * Enter saves, Escape cancels. Dispatches velin-data-table-edit.
+         */
+        _setupEditable() {
+          if (!this.hasAttribute("editable") && !this.querySelector("[data-editable]")) return;
+          const body = this._table.tBodies[0];
+          if (!body || body.dataset.velinEditBound) return;
+          body.dataset.velinEditBound = "true";
+          body.addEventListener("dblclick", (e) => {
+            const cell = e.target.closest("td");
+            if (!cell || !body.contains(cell)) return;
+            if (!this.hasAttribute("editable") && !cell.hasAttribute("data-editable")) return;
+            this._beginEdit(cell);
+          });
+          body.addEventListener("keydown", (e) => {
+            const cell = e.target.closest("td");
+            if (!cell || e.target !== cell) return;
+            if (e.key === "Enter" || e.key === "F2") {
+              if (!this.hasAttribute("editable") && !cell.hasAttribute("data-editable")) return;
+              e.preventDefault();
+              this._beginEdit(cell);
+            }
+          });
+          for (const cell of body.querySelectorAll("td[data-editable], td")) {
+            if (!this.hasAttribute("editable") && !cell.hasAttribute("data-editable")) continue;
+            if (!cell.hasAttribute("tabindex")) cell.setAttribute("tabindex", "0");
+          }
+        }
+        /** @param {HTMLTableCellElement} cell */
+        _beginEdit(cell) {
+          if (cell.querySelector("input")) return;
+          const previous = cell.textContent.trim();
+          const input = document.createElement("input");
+          input.className = "velin-input velin-data-table__edit";
+          input.value = previous;
+          input.setAttribute("aria-label", "Edit cell");
+          cell.textContent = "";
+          cell.appendChild(input);
+          input.focus();
+          input.select();
+          const commit = (save) => {
+            const next = save ? input.value.trim() : previous;
+            cell.textContent = next;
+            if (save && next !== previous) {
+              this.dispatchEvent(new CustomEvent("velin-data-table-edit", {
+                bubbles: true,
+                detail: {
+                  cell,
+                  row: cell.parentElement,
+                  previous,
+                  value: next,
+                  columnIndex: cell.cellIndex
+                }
+              }));
+              announce("Cell updated");
+            }
+          };
+          input.addEventListener("keydown", (e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              commit(true);
+            } else if (e.key === "Escape") {
+              e.preventDefault();
+              commit(false);
+            }
+          });
+          input.addEventListener("blur", () => commit(true));
+        }
+        _syncSortState() {
+          this._headers().forEach((header, index) => {
+            if (this._sortType(header) === "none") return;
+            const active = index === this._sortIndex;
+            header.setAttribute("aria-sort", active ? this._sortDirection : "none");
+            header.querySelector(".velin-data-table__sort")?.classList.toggle("velin-data-table__sort--active", active);
+          });
+        }
+        _bindFilterInput() {
+          if (this._filterEl) this._filterEl.removeEventListener("input", this._onFilterInput);
+          const selector = this.getAttribute("filter-input");
+          this._filterEl = selector ? document.querySelector(selector) : null;
+          if (this._filterEl) this._filterEl.addEventListener("input", this._onFilterInput);
+        }
+        _onFilterInput(event) {
+          if (this._filterTimer) clearTimeout(this._filterTimer);
+          const value = event.target.value;
+          this._filterTimer = setTimeout(() => this.filter(value), 150);
+        }
+        /** @param {HTMLTableRowElement} row */
+        _rowText(row) {
+          const scoped = [...row.cells].filter((cell) => cell.hasAttribute("data-filter"));
+          const cells = scoped.length ? scoped : [...row.cells];
+          return cells.map((cell) => cell.textContent || "").join(" ").toLowerCase();
+        }
+        // ── Rendering ──────────────────────────────────────────────────────────────
+        _render() {
+          const size = this.pageSize;
+          this._page = Math.min(this._page, this.pageCount);
+          const matching = this.matchingRows;
+          const start = size ? (this._page - 1) * size : 0;
+          const end = size ? start + size : matching.length;
+          for (const row of this.rows) {
+            const index = matching.indexOf(row);
+            row.hidden = index === -1 || index < start || index >= end;
+          }
+          this._renderEmptyState(matching.length === 0);
+          this._renderPagination();
+        }
+        /** @param {boolean} isEmpty */
+        _renderEmptyState(isEmpty) {
+          if (!isEmpty) {
+            this._emptyRow?.remove();
+            this._emptyRow = null;
+            return;
+          }
+          if (this._emptyRow?.isConnected) return;
+          const columns = this._headers().length || 1;
+          const row = document.createElement("tr");
+          row.className = "velin-data-table__empty";
+          const cell = document.createElement("td");
+          cell.colSpan = columns;
+          cell.textContent = this.getAttribute("empty-text") || "No matching rows";
+          row.appendChild(cell);
+          this._table.tBodies[0].appendChild(row);
+          this._emptyRow = row;
+        }
+        _renderPagination() {
+          if (!this.pageSize || this.pageCount <= 1) {
+            this._pagination?.remove();
+            this._pagination = null;
+            return;
+          }
+          if (!this._pagination?.isConnected) {
+            const nav = document.createElement("nav");
+            nav.className = "velin-data-table__pagination";
+            nav.setAttribute("aria-label", this.getAttribute("pagination-label") || "Table pagination");
+            const previous2 = document.createElement("button");
+            previous2.type = "button";
+            previous2.className = "velin-btn velin-btn--outline velin-btn--sm";
+            previous2.dataset.velinPage = "previous";
+            previous2.textContent = this.getAttribute("previous-text") || "Previous";
+            previous2.addEventListener("click", () => this.goToPage(this._page - 1));
+            const status2 = document.createElement("p");
+            status2.className = "velin-data-table__page-status";
+            status2.dataset.velinPage = "status";
+            const next2 = document.createElement("button");
+            next2.type = "button";
+            next2.className = "velin-btn velin-btn--outline velin-btn--sm";
+            next2.dataset.velinPage = "next";
+            next2.textContent = this.getAttribute("next-text") || "Next";
+            next2.addEventListener("click", () => this.goToPage(this._page + 1));
+            nav.append(previous2, status2, next2);
+            this.appendChild(nav);
+            this._pagination = nav;
+          }
+          const status = this._pagination.querySelector('[data-velin-page="status"]');
+          if (status) status.textContent = `Page ${this._page} of ${this.pageCount}`;
+          const previous = this._pagination.querySelector('[data-velin-page="previous"]');
+          const next = this._pagination.querySelector('[data-velin-page="next"]');
+          if (previous) previous.disabled = this._page <= 1;
+          if (next) next.disabled = this._page >= this.pageCount;
+        }
+      };
+      customElements.define("velin-data-table", VelinDataTable);
+      velin_data_table_default = VelinDataTable;
+    }
+  });
+
+  // components/velin-file-dropzone.js
+  var velin_file_dropzone_exports = {};
+  __export(velin_file_dropzone_exports, {
+    default: () => velin_file_dropzone_default
+  });
+  var styles28, VelinFileDropzone, velin_file_dropzone_default;
+  var init_velin_file_dropzone = __esm({
+    "components/velin-file-dropzone.js"() {
+      init_sanitize();
+      styles28 = `
+  :host { display: block; }
+  .zone {
+    border: 2px dashed var(--velin-color-border, #cbd5e1);
+    border-radius: var(--velin-radius-md, 0.5rem);
+    padding: var(--velin-space-6, 1.5rem);
+    background: var(--velin-color-surface-dim, var(--velin-color-bg-subtle, #f8fafc));
+    color: var(--velin-color-text, #111);
+    text-align: center;
+    transition: border-color 150ms ease, background 150ms ease;
+  }
+  :host([dragging]) .zone {
+    border-color: var(--velin-color-primary, #2563eb);
+    background: var(--velin-color-primary-subtle, #eff6ff);
+  }
+  .hint { margin: 0 0 var(--velin-space-3, 0.75rem); color: var(--velin-color-text-muted, #64748b); }
+  .browse {
+    display: inline-flex; align-items: center; justify-content: center;
+    min-block-size: 2.75rem; padding-inline: var(--velin-space-4, 1rem);
+    border-radius: var(--velin-radius-md, 0.5rem);
+    border: none; cursor: pointer;
+    background: var(--velin-color-primary, #2563eb);
+    color: var(--velin-color-on-primary, #fff);
+    font: inherit;
+  }
+  .browse:focus-visible { outline: 2px solid var(--velin-color-focus, #2563eb); outline-offset: 2px; }
+  input[type="file"] {
+    position: absolute; inline-size: 1px; block-size: 1px; padding: 0; margin: -1px;
+    overflow: hidden; clip: rect(0,0,0,0); border: 0;
+  }
+  .list { list-style: none; padding: 0; margin: var(--velin-space-4, 1rem) 0 0; text-align: start; }
+  .list li {
+    display: flex; justify-content: space-between; gap: var(--velin-space-3, 0.75rem);
+    padding: var(--velin-space-2, 0.5rem) 0;
+    border-block-end: 1px solid var(--velin-color-border, #e2e8f0);
+    font-size: var(--velin-text-sm, 0.875rem);
+  }
+  .progress {
+    margin-block-start: var(--velin-space-3, 0.75rem);
+    block-size: 0.5rem; border-radius: 999px;
+    background: var(--velin-color-border, #e2e8f0); overflow: hidden;
+  }
+  .bar {
+    block-size: 100%; inline-size: 0%;
+    background: var(--velin-color-primary, #2563eb);
+    transition: inline-size 150ms ease;
+  }
+  .status { margin: var(--velin-space-2, 0.5rem) 0 0; font-size: var(--velin-text-sm, 0.875rem); }
+  .status[data-tone="error"] { color: var(--velin-color-danger, #b91c1c); }
+`;
+      VelinFileDropzone = class extends HTMLElement {
+        static get observedAttributes() {
+          return ["accept", "multiple", "label", "progress"];
+        }
+        constructor() {
+          super();
+          this.attachShadow({ mode: "open" });
+          this._files = [];
+        }
+        connectedCallback() {
+          this._render();
+        }
+        attributeChangedCallback() {
+          if (this.shadowRoot?.querySelector(".zone")) this._render();
+        }
+        get files() {
+          return this._files.slice();
+        }
+        _emitFiles(fileList) {
+          const accept = this.getAttribute("accept");
+          const files = [...fileList];
+          if (accept) {
+            const parts = accept.split(",").map((s) => s.trim().toLowerCase());
+            const bad = files.find((f) => {
+              const name = f.name.toLowerCase();
+              const type = (f.type || "").toLowerCase();
+              return !parts.some((p) => p.startsWith(".") ? name.endsWith(p) : type === p || type.startsWith(p.replace("/*", "/")));
+            });
+            if (bad) {
+              this._setStatus(`File type not allowed: ${bad.name}`, "error");
+              this.dispatchEvent(new CustomEvent("velin-error", { bubbles: true, detail: { message: "accept", file: bad } }));
+              return;
+            }
+          }
+          this._files = files;
+          this._setStatus(files.length ? `${files.length} file(s) ready` : "", "ok");
+          this.dispatchEvent(new CustomEvent("velin-files", { bubbles: true, detail: { files } }));
+          this._renderList();
+        }
+        _setStatus(text2, tone = "ok") {
+          const el = this.shadowRoot?.querySelector(".status");
+          if (!el) return;
+          el.textContent = text2;
+          el.dataset.tone = tone;
+        }
+        _renderList() {
+          const ul = this.shadowRoot?.querySelector(".list");
+          if (!ul) return;
+          ul.innerHTML = this._files.map((f) => `<li><span>${escapeHTML(f.name)}</span><span>${Math.round(f.size / 1024)} KB</span></li>`).join("");
+        }
+        _render() {
+          const label = escapeHTML(this.getAttribute("label") || "Upload files");
+          const accept = this.getAttribute("accept") || "";
+          const multiple = this.hasAttribute("multiple");
+          const progress = Math.max(0, Math.min(100, Number(this.getAttribute("progress") || 0)));
+          this.shadowRoot.innerHTML = `
+      <style>${styles28}</style>
+      <div class="zone" role="group" aria-label="${label}">
+        <p class="hint">Drag and drop files here, or browse. Client-side only \u2014 wire <code>velin-files</code> to your upload API.</p>
+        <button type="button" class="browse">Browse files</button>
+        <input type="file" ${accept ? `accept="${escapeHTML(accept)}"` : ""} ${multiple ? "multiple" : ""} />
+        <div class="progress" hidden="${progress <= 0 ? "true" : "false"}" aria-hidden="${progress <= 0 ? "true" : "false"}">
+          <div class="bar" style="inline-size:${progress}%"></div>
+        </div>
+        <p class="status" role="status" aria-live="polite"></p>
+        <ul class="list"></ul>
+      </div>
+    `;
+          const input = this.shadowRoot.querySelector("input");
+          const browse = this.shadowRoot.querySelector(".browse");
+          const zone = this.shadowRoot.querySelector(".zone");
+          browse.addEventListener("click", () => input.click());
+          input.addEventListener("change", () => {
+            if (input.files?.length) this._emitFiles(input.files);
+          });
+          ["dragenter", "dragover"].forEach((ev) => {
+            zone.addEventListener(ev, (e) => {
+              e.preventDefault();
+              this.setAttribute("dragging", "");
+            });
+          });
+          ["dragleave", "drop"].forEach((ev) => {
+            zone.addEventListener(ev, (e) => {
+              e.preventDefault();
+              this.removeAttribute("dragging");
+            });
+          });
+          zone.addEventListener("drop", (e) => {
+            const list = e.dataTransfer?.files;
+            if (list?.length) this._emitFiles(list);
+          });
+          this._renderList();
+        }
+      };
+      customElements.define("velin-file-dropzone", VelinFileDropzone);
+      velin_file_dropzone_default = VelinFileDropzone;
+    }
+  });
+
+  // components/velin-form-summary.js
+  var velin_form_summary_exports = {};
+  __export(velin_form_summary_exports, {
+    default: () => velin_form_summary_default
+  });
+  function escapeSelector(value) {
+    const text2 = String(value ?? "");
+    if (typeof CSS !== "undefined" && typeof CSS.escape === "function") return CSS.escape(text2);
+    return text2.replace(/[^\w-]/g, (char) => `\\${char}`);
+  }
+  function fieldLabel(field) {
+    const explicit = field.getAttribute("data-error-label");
+    if (explicit) return explicit;
+    const ariaLabel = field.getAttribute("aria-label");
+    if (ariaLabel?.trim()) return ariaLabel.trim();
+    const labelledBy = field.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      const text2 = labelledBy.split(/\s+/).map((id) => field.ownerDocument.getElementById(id)?.textContent?.trim() || "").filter(Boolean).join(" ");
+      if (text2) return text2;
+    }
+    if (field.id) {
+      const label = field.ownerDocument.querySelector(`label[for="${escapeSelector(field.id)}"]`);
+      if (label?.textContent.trim()) return label.textContent.trim();
+    }
+    const wrapping = field.closest("label");
+    if (wrapping?.textContent.trim()) return wrapping.textContent.trim();
+    return field.name || "This field";
+  }
+  function fieldMessage(field) {
+    return field.getAttribute("data-error-message")?.trim() || field.validationMessage || "Invalid value";
+  }
+  function addDescribedBy(field, id) {
+    const ids = (field.getAttribute("aria-describedby") || "").split(/\s+/).filter(Boolean);
+    if (!ids.includes(id)) {
+      ids.push(id);
+      field.setAttribute("aria-describedby", ids.join(" "));
+    }
+  }
+  function removeDescribedBy(field, id) {
+    const ids = (field.getAttribute("aria-describedby") || "").split(/\s+/).filter(Boolean);
+    const next = ids.filter((value) => value !== id);
+    if (next.length) field.setAttribute("aria-describedby", next.join(" "));
+    else field.removeAttribute("aria-describedby");
+  }
+  var FIELD_SELECTOR, IGNORED_TYPES, fieldIdCounter, VelinFormSummary, velin_form_summary_default;
+  var init_velin_form_summary = __esm({
+    "components/velin-form-summary.js"() {
+      init_a11y_utils();
+      FIELD_SELECTOR = "input, select, textarea";
+      IGNORED_TYPES = /* @__PURE__ */ new Set(["submit", "reset", "button", "image", "hidden"]);
+      fieldIdCounter = 0;
+      VelinFormSummary = class extends HTMLElement {
+        static get observedAttributes() {
+          return ["for", "heading"];
+        }
+        constructor() {
+          super();
+          this._form = null;
+          this._panel = null;
+          this._errors = [];
+          this._onSubmit = this._onSubmit.bind(this);
+          this._onFieldChange = this._onFieldChange.bind(this);
+          this._onReset = this._onReset.bind(this);
+        }
+        connectedCallback() {
+          this.classList.add("velin-form-summary");
+          requestAnimationFrame(() => this._bindForm());
+        }
+        disconnectedCallback() {
+          this._unbindForm();
+        }
+        attributeChangedCallback(name, previous, next) {
+          if (previous === next) return;
+          if (name === "for" && this.isConnected) {
+            this._unbindForm();
+            this._bindForm();
+          } else if (name === "heading" && this._panel) {
+            const heading = this._panel.querySelector(".velin-form-summary__heading");
+            if (heading) heading.textContent = this.headingText;
+          }
+        }
+        // ── Public API ─────────────────────────────────────────────────────────────
+        get form() {
+          return this._form;
+        }
+        /** @returns {{ field: HTMLElement, label: string, message: string }[]} */
+        get errors() {
+          return this._errors.slice();
+        }
+        get headingText() {
+          return this.getAttribute("heading") || "There is a problem";
+        }
+        /** Validate the form and render the summary. @returns {boolean} valid */
+        validate() {
+          if (!this._form) return true;
+          const errors = [];
+          for (const field of this._fields()) {
+            if (field.checkValidity()) {
+              this._clearFieldError(field);
+              continue;
+            }
+            const error = { field, label: fieldLabel(field), message: fieldMessage(field) };
+            this._markFieldError(field, error.message);
+            errors.push(error);
+          }
+          this._errors = errors;
+          this._render();
+          return errors.length === 0;
+        }
+        /** Remove the summary and all field error state. */
+        clear() {
+          for (const field of this._fields()) this._clearFieldError(field);
+          this._errors = [];
+          this._render();
+        }
+        /** Move focus to the first field with an error. */
+        focusFirstError() {
+          const first = this._errors[0];
+          if (first) this._focusField(first.field);
+        }
+        // ── Form wiring ────────────────────────────────────────────────────────────
+        _bindForm() {
+          const id = this.getAttribute("for");
+          this._form = id ? this.ownerDocument.getElementById(id) : this.closest("form");
+          if (!this._form) return;
+          if (!this.hasAttribute("native-validation")) this._form.noValidate = true;
+          this._form.addEventListener("submit", this._onSubmit);
+          this._form.addEventListener("reset", this._onReset);
+          this._form.addEventListener("input", this._onFieldChange);
+          this._form.addEventListener("change", this._onFieldChange);
+        }
+        _unbindForm() {
+          if (!this._form) return;
+          this._form.removeEventListener("submit", this._onSubmit);
+          this._form.removeEventListener("reset", this._onReset);
+          this._form.removeEventListener("input", this._onFieldChange);
+          this._form.removeEventListener("change", this._onFieldChange);
+          this._form = null;
+        }
+        /** @returns {HTMLElement[]} */
+        _fields() {
+          if (!this._form) return [];
+          const seenRadioNames = /* @__PURE__ */ new Set();
+          return [...this._form.querySelectorAll(FIELD_SELECTOR)].filter((field) => {
+            if (IGNORED_TYPES.has(field.type)) return false;
+            if (field.disabled || field.hasAttribute("data-error-ignore")) return false;
+            if (typeof field.checkValidity !== "function") return false;
+            if (field.type === "radio" && field.name) {
+              if (seenRadioNames.has(field.name)) return false;
+              seenRadioNames.add(field.name);
+            }
+            return true;
+          });
+        }
+        _onSubmit(event) {
+          if (this.validate()) return;
+          event.preventDefault();
+          this._announceErrors();
+          this._focusPanel();
+          this.dispatchEvent(new CustomEvent("velin-form-invalid", {
+            bubbles: true,
+            detail: { errors: this.errors.map(({ label, message }) => ({ label, message })) }
+          }));
+        }
+        _onReset() {
+          requestAnimationFrame(() => this.clear());
+        }
+        /** Re-validate a single field once it already had an error, never before. */
+        _onFieldChange(event) {
+          const field = event.target;
+          if (!field || !this._errors.some((error) => error.field === field)) return;
+          if (!field.checkValidity()) return;
+          this._clearFieldError(field);
+          this._errors = this._errors.filter((error) => error.field !== field);
+          this._render();
+          if (this._errors.length === 0) {
+            this.dispatchEvent(new CustomEvent("velin-form-valid", { bubbles: true }));
+          }
+        }
+        // ── Field state ────────────────────────────────────────────────────────────
+        /** @param {HTMLElement} field */
+        _errorId(field) {
+          if (!field.id) field.id = `velin-field-${++fieldIdCounter}`;
+          return `${field.id}-error`;
+        }
+        /**
+         * @param {HTMLElement} field
+         * @param {string} message
+         */
+        _markFieldError(field, message) {
+          const errorId = this._errorId(field);
+          field.setAttribute("aria-invalid", "true");
+          let holder = this.ownerDocument.getElementById(errorId);
+          if (!holder) {
+            holder = this._form.querySelector(`[data-velin-error-for="${escapeSelector(field.name || field.id)}"]`);
+          }
+          if (!holder) {
+            holder = this.ownerDocument.createElement("p");
+            holder.dataset.velinErrorGenerated = "true";
+            field.insertAdjacentElement("afterend", holder);
+          }
+          holder.id = errorId;
+          holder.classList.add("velin-field-error");
+          holder.textContent = message;
+          addDescribedBy(field, errorId);
+        }
+        /** @param {HTMLElement} field */
+        _clearFieldError(field) {
+          if (!field.id) return;
+          const errorId = `${field.id}-error`;
+          field.removeAttribute("aria-invalid");
+          removeDescribedBy(field, errorId);
+          const holder = this.ownerDocument.getElementById(errorId);
+          if (!holder) return;
+          if (holder.dataset.velinErrorGenerated) holder.remove();
+          else holder.textContent = "";
+        }
+        /** @param {HTMLElement} field */
+        _focusField(field) {
+          const target = field.type === "radio" && field.name ? this._form.querySelector(`input[type="radio"][name="${escapeSelector(field.name)}"]`) || field : field;
+          target.focus();
+          this.dispatchEvent(new CustomEvent("velin-form-error-focus", {
+            bubbles: true,
+            detail: { name: target.name || target.id }
+          }));
+        }
+        // ── Summary panel ──────────────────────────────────────────────────────────
+        _render() {
+          if (!this._errors.length) {
+            this._panel?.remove();
+            this._panel = null;
+            this.hidden = true;
+            return;
+          }
+          this.hidden = false;
+          if (!this._panel?.isConnected) {
+            const panel = this.ownerDocument.createElement("div");
+            panel.className = "velin-form-summary__panel velin-alert velin-alert--danger";
+            panel.setAttribute("role", "alert");
+            panel.tabIndex = -1;
+            const heading = this.ownerDocument.createElement("p");
+            heading.className = "velin-form-summary__heading";
+            heading.textContent = this.headingText;
+            const list2 = this.ownerDocument.createElement("ul");
+            list2.className = "velin-form-summary__list";
+            panel.append(heading, list2);
+            this.appendChild(panel);
+            this._panel = panel;
+          }
+          const list = this._panel.querySelector(".velin-form-summary__list");
+          list.textContent = "";
+          for (const error of this._errors) {
+            const item = this.ownerDocument.createElement("li");
+            const link = this.ownerDocument.createElement("a");
+            link.href = `#${this._errorId(error.field).replace(/-error$/, "")}`;
+            link.textContent = `${error.label}: ${error.message}`;
+            link.addEventListener("click", (event) => {
+              event.preventDefault();
+              this._focusField(error.field);
+            });
+            item.appendChild(link);
+            list.appendChild(item);
+          }
+        }
+        _focusPanel() {
+          this._panel?.focus();
+        }
+        _announceErrors() {
+          const count = this._errors.length;
+          announce(count === 1 ? "1 field needs attention" : `${count} fields need attention`, "assertive");
+        }
+      };
+      customElements.define("velin-form-summary", VelinFormSummary);
+      velin_form_summary_default = VelinFormSummary;
+    }
+  });
+
   // components/velin-live-dot.js
   var velin_live_dot_exports = {};
   __export(velin_live_dot_exports, {
     default: () => velin_live_dot_default
   });
-  var STATUS_COLORS, styles28, KEYFRAMES_FALLBACK, VelinLiveDot, velin_live_dot_default;
+  var STATUS_COLORS, styles29, KEYFRAMES_FALLBACK, VelinLiveDot, velin_live_dot_default;
   var init_velin_live_dot = __esm({
     "components/velin-live-dot.js"() {
       init_a11y_utils();
@@ -6324,7 +7981,7 @@
         error: "var(--velin-color-danger, oklch(60% 0.2 25))",
         muted: "var(--velin-color-border, oklch(85% 0.01 240))"
       };
-      styles28 = `
+      styles29 = `
   :host {
     display: inline-flex;
     align-items: center;
@@ -6374,7 +8031,7 @@
           this.setAttribute("aria-label", label);
           this.style.setProperty("--velin-live-color", color);
           this.shadowRoot.innerHTML = `
-      <style>${styles28}${KEYFRAMES_FALLBACK}</style>
+      <style>${styles29}${KEYFRAMES_FALLBACK}</style>
       <span class="dot" aria-hidden="true"></span><slot></slot>
     `;
         }
@@ -6992,7 +8649,7 @@
             return;
           }
           if (!this._indexLoaded) await this._loadIndex();
-          const { groups } = this._search.query(q, {
+          const { groups } = await this._search.query(q, {
             minChars: this.minChars,
             fuzzy: this.fuzzy,
             categories: this.categories || void 0,
@@ -7123,11 +8780,11 @@
       cipher: Array.from(new Uint8Array(cipher))
     });
   }
-  var styles29, VelinSecureField, velin_secure_field_default;
+  var styles30, VelinSecureField, velin_secure_field_default;
   var init_velin_secure_field = __esm({
     "components/velin-secure-field.js"() {
       init_sanitize();
-      styles29 = `
+      styles30 = `
   :host { display: block; }
   label { display: block; font-size: var(--velin-text-sm); margin-block-end: var(--velin-space-1); }
   input {
@@ -7177,7 +8834,7 @@
           const input = this.shadowRoot?.querySelector("input");
           if (input && this._onChange) input.removeEventListener("change", this._onChange);
           this.shadowRoot.innerHTML = `
-      <style>${styles29}</style>
+      <style>${styles30}</style>
       <label for="${id}">${escapeHTML(label)}</label>
       <input id="${id}" type="${type}" autocomplete="${autocomplete}" part="input" />
       <p class="velin-field-help">Demo-only client encoding \u2014 use HTTPS and server-side crypto for real secrets.</p>
@@ -7397,6 +9054,7 @@
         "velin-accordion": () => Promise.resolve().then(() => (init_velin_accordion(), velin_accordion_exports)),
         "velin-announcer": () => Promise.resolve().then(() => (init_velin_announcer(), velin_announcer_exports)),
         "velin-bottom-nav": () => Promise.resolve().then(() => (init_velin_bottom_nav(), velin_bottom_nav_exports)),
+        "velin-calendar": () => Promise.resolve().then(() => (init_velin_calendar(), velin_calendar_exports)),
         "velin-carousel": () => Promise.resolve().then(() => (init_velin_carousel(), velin_carousel_exports)),
         "velin-code-block": () => Promise.resolve().then(() => (init_velin_code_block(), velin_code_block_exports)),
         "velin-collapse": () => Promise.resolve().then(() => (init_velin_collapse(), velin_collapse_exports)),
@@ -7405,10 +9063,13 @@
         "velin-copy": () => Promise.resolve().then(() => (init_velin_copy(), velin_copy_exports)),
         "velin-countdown": () => Promise.resolve().then(() => (init_velin_countdown(), velin_countdown_exports)),
         "velin-counter": () => Promise.resolve().then(() => (init_velin_counter(), velin_counter_exports)),
+        "velin-data-table": () => Promise.resolve().then(() => (init_velin_data_table(), velin_data_table_exports)),
         "velin-dialog": () => Promise.resolve().then(() => (init_velin_dialog(), velin_dialog_exports)),
         "velin-drawer": () => Promise.resolve().then(() => (init_velin_drawer(), velin_drawer_exports)),
         "velin-dropdown": () => Promise.resolve().then(() => (init_velin_dropdown(), velin_dropdown_exports)),
         "velin-email": () => Promise.resolve().then(() => (init_velin_email(), velin_email_exports)),
+        "velin-file-dropzone": () => Promise.resolve().then(() => (init_velin_file_dropzone(), velin_file_dropzone_exports)),
+        "velin-form-summary": () => Promise.resolve().then(() => (init_velin_form_summary(), velin_form_summary_exports)),
         "velin-icon": () => Promise.resolve().then(() => (init_velin_icon(), velin_icon_exports)),
         "velin-lightbox": () => Promise.resolve().then(() => (init_velin_lightbox(), velin_lightbox_exports)),
         "velin-live-dot": () => Promise.resolve().then(() => (init_velin_live_dot(), velin_live_dot_exports)),
@@ -8024,6 +9685,10 @@
   init_velin_counter();
   init_velin_live_dot();
   init_velin_code_block();
+  init_velin_data_table();
+  init_velin_form_summary();
+  init_velin_calendar();
+  init_velin_file_dropzone();
   init_velin_search();
   init_velin_search();
 
@@ -8246,5 +9911,5 @@
 /*! Bundled license information:
 
 dompurify/dist/purify.es.mjs:
-  (*! @license DOMPurify 3.4.5 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.5/LICENSE *)
+  (*! @license DOMPurify 3.4.12 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.12/LICENSE *)
 */