@swisspost/design-system-components 10.0.0-next.50 → 10.0.0-next.52

package/dist/components/post-popover-trigger.js

@@ -0,0 +1,132 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { v as version } from './package.js';
+import { i as isFocusable } from './focusable.js';
+import { c as checkRequiredAndType } from './index2.js';
+import './breakpoints.js';
+
+const postPopoverTriggerCss = ":host{cursor:pointer}";
+
+const PostPopoverTrigger$1 = /*@__PURE__*/ proxyCustomElement(class PostPopoverTrigger extends HTMLElement {
+    syncAriaExpanded(newValue) {
+        this.ariaExpanded = newValue;
+        if (this.trigger) {
+            this.trigger.setAttribute('aria-expanded', String(newValue));
+        }
+    }
+    /**
+     * Watch for changes to the `for` property to validate its type and ensure it is a string.
+     * @param forValue - The new value of the `for` property.
+     */
+    validateFor() {
+        checkRequiredAndType(this, 'for', 'string');
+    }
+    // Gets the associated popover element to the trigger based on 'for'
+    get popover() {
+        const ref = document.getElementById(this.for);
+        return ref?.localName === 'post-popover' ? ref : null;
+    }
+    setupTrigger() {
+        this.trigger = this.host.querySelector('*');
+        if (this.trigger) {
+            this.trigger.setAttribute('aria-expanded', this.ariaExpanded.toString());
+            // check if its not focusable and add aria role and tabindex
+            if (!isFocusable(this.trigger)) {
+                this.trigger.setAttribute('tabindex', '0');
+                this.trigger.setAttribute('role', 'button');
+            }
+            // Set aria attributes
+            this.trigger.setAttribute('aria-haspopup', 'true');
+            this.trigger.setAttribute('aria-controls', this.for);
+            this.trigger.addEventListener('click', this.boundHandleToggle);
+            this.trigger.addEventListener('keydown', this.boundHandleKeyDown);
+        }
+        else {
+            console.error('No content found in the post-popover-trigger slot. Please insert a focusable element or content that can receive focus.');
+        }
+    }
+    handleToggle() {
+        const popoverEl = this.popover;
+        if (popoverEl) {
+            popoverEl.toggle(this.trigger);
+            this.focusTrigger();
+        }
+        else {
+            console.warn(`No post-popover found with ID: ${this.for}`);
+        }
+    }
+    focusTrigger() {
+        // Restores focus to the trigger
+        if (!this.popoverOpen && this.trigger) {
+            this.trigger.focus();
+        }
+    }
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        /**
+         * Manages the accessibility attribute `aria-expanded` to indicate whether the associated popover is expanded or collapsed.
+         */
+        this.ariaExpanded = false;
+        /**
+         * Holds the state of the popover toggle
+         */
+        this.popoverOpen = false;
+        this.handleKeyDown = (e) => {
+            if (e.key === 'Enter' || e.key === ' ') {
+                e.preventDefault();
+                this.handleToggle();
+            }
+        };
+        this.boundHandleToggle = this.handleToggle.bind(this);
+        this.boundHandleKeyDown = this.handleKeyDown.bind(this);
+        this.boundHandlePostToggle = (event) => {
+            this.popoverOpen = event.detail.isOpen;
+            this.focusTrigger();
+        };
+    }
+    componentDidLoad() {
+        this.validateFor();
+        this.setupTrigger();
+        this.popover?.addEventListener('postToggle', this.boundHandlePostToggle);
+    }
+    disconnectedCallback() {
+        this.trigger.removeEventListener('click', this.boundHandleToggle);
+        this.trigger.removeEventListener('keydown', this.boundHandleKeyDown);
+        this.popover?.removeEventListener('postToggle', this.boundHandlePostToggle);
+    }
+    render() {
+        return (h(Host, { key: 'd7467aa400f407d76df06e8bbc84210e5f016073', "data-version": version }, h("slot", { key: '618f3d14fb89b3ad3c101a58f8519c337d9f1721', onSlotchange: () => this.setupTrigger() })));
+    }
+    get host() { return this; }
+    static get watchers() { return {
+        "popoverOpen": ["syncAriaExpanded"],
+        "for": ["validateFor"]
+    }; }
+    static get style() { return postPopoverTriggerCss; }
+}, [1, "post-popover-trigger", {
+        "for": [513],
+        "ariaExpanded": [32],
+        "popoverOpen": [32]
+    }, undefined, {
+        "popoverOpen": ["syncAriaExpanded"],
+        "for": ["validateFor"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["post-popover-trigger"];
+    components.forEach(tagName => { switch (tagName) {
+        case "post-popover-trigger":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, PostPopoverTrigger$1);
+            }
+            break;
+    } });
+}
+
+const PostPopoverTrigger = PostPopoverTrigger$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { PostPopoverTrigger, defineCustomElement };

package/dist/components/post-popover.js

@@ -1,71 +1,19 @@
 import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
 import { a as PLACEMENT_TYPES, d as defineCustomElement$2 } from './post-popovercontainer2.js';
 import { v as version } from './package.js';
-import { I as IS_BROWSER } from './breakpoints.js';
+import { a as getDeepFocusableChildren } from './get-focusable-children.js';
 import { d as checkEmptyOrOneOf, c as checkRequiredAndType } from './index2.js';
+import './breakpoints.js';
 import { d as defineCustomElement$4 } from './post-closebutton2.js';
 import { d as defineCustomElement$3 } from './post-icon2.js';
 
-function getAttributeObserver(attribute, handler) {
-    /**
-     * Handle attribute changes and childList changes from the observer
-     * @param {MutationRecord[]} mutationList
-     */
-    function observerHandler(mutationList) {
-        mutationList.forEach(mutation => {
-            if (mutation.type === 'attributes' && mutation.attributeName === attribute) {
-                handler(mutation.target);
-            }
-            if (mutation.type === 'childList') {
-                mutation.addedNodes.forEach(node => {
-                    if (node.nodeType === Node.ELEMENT_NODE &&
-                        node.hasAttribute(attribute)) {
-                        handler(node);
-                    }
-                });
-            }
-        });
-    }
-    // Initialize a mutation observer for patching accessibility features
-    return IS_BROWSER ? new MutationObserver(observerHandler) : null;
-}
-
 const postPopoverCss = "*{box-sizing:border-box}:host{display:block}.visually-hidden{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);border:0}.popover-container{color:var(--post-current-fg);background-color:var(--post-current-bg);display:flex;align-items:self-start;padding:.5em;min-width:160px;max-width:min(var(--post-popover-max-width, 280px),100vw)}.popover-content{padding:.5em;flex-grow:1}";
 
-/**
- * @slot default - Slot for placing content inside the popover.
- */
-let popoverInstances = 0;
-const popoverTargetAttribute = 'data-popover-target';
-const globalToggleHandler = (e) => {
-    let currentElement = e.target;
-    // Traverse up the DOM tree to find if any parent has the popover target attribute
-    while (currentElement && !currentElement.getAttribute(popoverTargetAttribute)) {
-        if (currentElement === document.body || !currentElement.parentElement)
-            break;
-        currentElement = currentElement.parentElement;
-    }
-    const popoverTarget = currentElement?.getAttribute(popoverTargetAttribute);
-    if (!popoverTarget || ('key' in e && e.key !== 'Enter'))
-        return;
-    const popover = document.getElementById(popoverTarget);
-    popover?.toggle(currentElement);
-};
 const PostPopover$1 = /*@__PURE__*/ proxyCustomElement(class PostPopover extends HTMLElement {
-    validatePlacement() {
-        checkEmptyOrOneOf(this, 'placement', PLACEMENT_TYPES);
-    }
-    validateCloseButtonCaption() {
-        checkRequiredAndType(this, 'closeButtonCaption', 'string');
-    }
     constructor() {
         super();
         this.__registerHost();
         this.__attachShadow();
-        // Initialize a mutation observer for patching accessibility features
-        this.triggerObserver = IS_BROWSER
-            ? getAttributeObserver(popoverTargetAttribute, this.patchAccessibilityFeatures)
-            : null;
         /**
          * Defines the position of the popover relative to its trigger.
          * Popovers are automatically flipped to the opposite side if there is not enough available space and are shifted towards the viewport if they would overlap edge boundaries.
@@ -77,76 +25,46 @@ const PostPopover$1 = /*@__PURE__*/ proxyCustomElement(class PostPopover extends
          */
         // eslint-disable-next-line @stencil-community/ban-default-true
         this.arrow = true;
-        this.localBeforeToggleHandler = this.beforeToggleHandler.bind(this);
     }
-    connectedCallback() {
-        // Set up accessibility patcher and event listeners for the first component
-        if (popoverInstances === 0) {
-            window.addEventListener('pointerup', globalToggleHandler);
-            window.addEventListener('keydown', globalToggleHandler);
-            this.triggerObserver?.observe(document.body, {
-                subtree: true,
-                childList: true,
-                attributeFilter: [popoverTargetAttribute],
-            });
-        }
-        popoverInstances++;
-        this.triggers.forEach(trigger => trigger.setAttribute('aria-expanded', 'false'));
+    validatePlacement() {
+        checkEmptyOrOneOf(this, 'placement', PLACEMENT_TYPES);
+    }
+    validateCloseButtonCaption() {
+        checkRequiredAndType(this, 'closeButtonCaption', 'string');
     }
     componentDidLoad() {
         this.validatePlacement();
         this.validateCloseButtonCaption();
-        this.popoverRef.addEventListener('beforetoggle', this.localBeforeToggleHandler);
-    }
-    disconnectedCallback() {
-        popoverInstances--;
-        // Remove listeners and observer after the last popover has been destructed
-        if (popoverInstances === 0) {
-            window.removeEventListener('click', globalToggleHandler);
-            window.removeEventListener('keydown', globalToggleHandler);
-            this.triggerObserver?.disconnect();
-        }
-        this.popoverRef.removeEventListener('beforetoggle', this.localBeforeToggleHandler);
-        this.triggers.forEach(trigger => trigger.removeAttribute('aria-expanded'));
     }
     /**
      * Programmatically display the popover
-     * @param target An element with [data-popover-target="id"] where the popover should be shown
+     * @param target A focusable element inside the <post-popover-trigger> component that controls the popover
      */
     async show(target) {
         this.popoverRef.show(target);
-        console.log(this.popoverRef);
-        target.setAttribute('aria-expanded', 'true');
     }
     /**
      * Programmatically hide this popover
      */
     async hide() {
         this.popoverRef.hide();
-        this.triggers.forEach(trigger => trigger.setAttribute('aria-expanded', 'false'));
     }
     /**
      * Toggle popover display
-     * @param target An element with [data-popover-target="id"] where the popover should be anchored to
+     * @param target A focusable element inside the <post-popover-trigger> component that controls the popover
      * @param force Pass true to always show or false to always hide
      */
     async toggle(target, force) {
-        const newState = await this.popoverRef.toggle(target, force);
-        this.triggers.forEach(trigger => trigger.setAttribute('aria-expanded', 'false'));
-        target.setAttribute('aria-expanded', `${newState}`);
-    }
-    get triggers() {
-        return document.querySelectorAll(`[${popoverTargetAttribute}="${this.host.id}"]`);
-    }
-    beforeToggleHandler() {
-        this.triggers.forEach(trigger => trigger.setAttribute('aria-expanded', 'false'));
-    }
-    patchAccessibilityFeatures(trigger) {
-        const force = trigger.hasAttribute(popoverTargetAttribute);
-        trigger.setAttribute('aria-expanded', force ? 'false' : null);
+        await this.popoverRef.toggle(target, force);
+        const focusableChildren = getDeepFocusableChildren(this.host);
+        // find first focusable element
+        const firstFocusable = focusableChildren[0];
+        if (firstFocusable) {
+            firstFocusable.focus();
+        }
     }
     render() {
-        return (h(Host, { key: '4224bfe1dc1bdb7fdfb86da67b54816e8cc6fce4', "data-version": version }, h("post-popovercontainer", { key: '3d7e370a89214878d33598cafd3d118c74d16312', arrow: this.arrow, placement: this.placement, ref: e => (this.popoverRef = e) }, h("div", { key: 'ed806f93ddec2656a15a1b242246c9c09b34f58a', class: "popover-container" }, h("div", { key: 'd60dd75153f88fc65d56dc9ec7387363e78cb835', class: "popover-content" }, h("slot", { key: 'f37005a225ecde32a80dd5efc3e61ccea7ab6dc5' })), h("post-closebutton", { key: 'c440bc94fb2832a8b8fcc0dd545b5f9d65cf834a', onClick: () => this.hide() }, this.closeButtonCaption)))));
+        return (h(Host, { key: '82f8d89013b8ddb37fb924c9608ba394c669f35a', "data-version": version }, h("post-popovercontainer", { key: 'cf276e5faf65ae27bc0d8e51779de5470a1e49a3', arrow: this.arrow, placement: this.placement, ref: e => (this.popoverRef = e) }, h("div", { key: '9ab455b2ee7d7f082dc6fc588d519d7a362cad8c', class: "popover-container" }, h("div", { key: 'b3b468da2ff7ccb2a47d69a1841488359763e927', class: "popover-content" }, h("slot", { key: 'a32099475baaca02ce41350e36d363614a6f83ef' })), h("post-closebutton", { key: 'eac806bd1e6652cacce58fb7e915d66e82c24980', onClick: () => this.hide() }, this.closeButtonCaption)))));
     }
     get host() { return this; }
     static get watchers() { return {

package/dist/components/post-popovercontainer2.js

@@ -1323,14 +1323,9 @@ function getWindowScrollBarX(element, rect) {
   return rect.left + leftScroll;
 }
 
-function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
-  if (ignoreScrollbarX === void 0) {
-    ignoreScrollbarX = false;
-  }
+function getHTMLOffset(documentElement, scroll) {
   const htmlRect = documentElement.getBoundingClientRect();
-  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
-  // RTL <body> scrollbar.
-  getWindowScrollBarX(documentElement, htmlRect));
+  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
   const y = htmlRect.top + scroll.scrollTop;
   return {
     x,
@@ -1369,7 +1364,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -1403,6 +1398,10 @@ function getDocumentRect(element) {
   };
 }
 
+// Safety check: ensure the scrollbar space is reasonable in case this
+// calculation is affected by unusual styles.
+// Most scrollbars leave 15-18px of space.
+const SCROLLBAR_MAX = 25;
 function getViewportRect(element, strategy) {
   const win = getWindow(element);
   const html = getDocumentElement(element);
@@ -1420,6 +1419,24 @@ function getViewportRect(element, strategy) {
       y = visualViewport.offsetTop;
     }
   }
+  const windowScrollbarX = getWindowScrollBarX(html);
+  // <html> `overflow: hidden` + `scrollbar-gutter: stable` reduces the
+  // visual width of the <html> but this is not considered in the size
+  // of `html.clientWidth`.
+  if (windowScrollbarX <= 0) {
+    const doc = html.ownerDocument;
+    const body = doc.body;
+    const bodyStyles = getComputedStyle(body);
+    const bodyMarginInline = doc.compatMode === 'CSS1Compat' ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
+      width -= clippingStableScrollbarWidth;
+    }
+  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
+    // If the <body> scrollbar is on the left, the width needs to be extended
+    // by the scrollbar amount so there isn't extra space on the right.
+    width += windowScrollbarX;
+  }
   return {
     width,
     height,
@@ -2728,8 +2745,12 @@ const PostPopovercontainer = /*@__PURE__*/ proxyCustomElement(class PostPopoverc
     constructor() {
         super();
         this.__registerHost();
+        this.postBeforeShow = createEvent(this, "postBeforeShow", 7);
+        this.postShow = createEvent(this, "postShow", 7);
+        this.postHide = createEvent(this, "postHide", 7);
+        this.postBeforeToggle = createEvent(this, "postBeforeToggle", 7);
         this.postToggle = createEvent(this, "postToggle", 7);
-        this.firstOpen = true;
+        this.hasOpenedOnce = true;
         /**
          * Defines the placement of the popovercontainer according to the floating-ui options available at https://floating-ui.com/docs/computePosition#placement.
          * Popovercontainers are automatically flipped to the opposite side if there is not enough available space and are shifted
@@ -2783,36 +2804,79 @@ const PostPopovercontainer = /*@__PURE__*/ proxyCustomElement(class PostPopoverc
         if (typeof this.clearAutoUpdate === 'function') {
             this.clearAutoUpdate();
         }
+        this.host.removeEventListener('beforetoggle', this.handleToggle.bind(this));
     }
     /**
      * Programmatically display the popovercontainer
-     * @param target An element with [data-popover-target="id"] where the popovercontainer should be shown
+     * @param target A focusable element inside the <post-popover-trigger> component that controls the popover
      */
     async show(target) {
         if (this.toggleTimeoutId)
             return;
         this.eventTarget = target;
+        if (this.toggleTimeoutId)
+            return;
         this.calculatePosition();
         this.host.showPopover();
     }
+    /**
+     * Handles the popover opening process and emits related events.
+     */
+    async open() {
+        const content = this.host.querySelector('.popover-content');
+        this.startAutoupdates();
+        if (content) {
+            const animation = popIn(content);
+            if (animation?.playState === 'running') {
+                this.postBeforeToggle.emit({ willOpen: true });
+                this.postBeforeShow.emit({ first: this.hasOpenedOnce });
+            }
+            animation?.finished.then(() => {
+                this.postToggle.emit({ isOpen: true });
+                this.postShow.emit({ first: this.hasOpenedOnce });
+                if (this.hasOpenedOnce)
+                    this.hasOpenedOnce = false;
+            });
+        }
+        if (this.safeSpace) {
+            window.addEventListener('mousemove', this.mouseTrackingHandler.bind(this));
+        }
+    }
+    /**
+     * Handles the popover closing process and emits related events.
+     */
+    async close() {
+        if (typeof this.clearAutoUpdate === 'function') {
+            this.clearAutoUpdate();
+        }
+        if (this.safeSpace) {
+            window.removeEventListener('mousemove', this.mouseTrackingHandler.bind(this));
+        }
+        this.postToggle.emit({ isOpen: false });
+        this.postHide.emit();
+    }
     /**
      * Programmatically hide the popovercontainer
      */
     async hide() {
         if (!this.toggleTimeoutId) {
+            if (this.eventTarget && this.eventTarget instanceof HTMLElement$1) {
+                this.eventTarget.focus();
+            }
             this.eventTarget = null;
             this.host.hidePopover();
+            this.postHide.emit();
         }
     }
     /**
      * Toggle popovercontainer display
-     * @param target An element with [data-popover-target="id"] where the popovercontainer should be shown
+     * @param target A focusable element inside the <post-popover-trigger> component that controls the popover
      * @param force Pass true to always show or false to always hide
      */
     async toggle(target, force) {
+        this.eventTarget = target;
         // Prevent instant double toggle
         if (!this.toggleTimeoutId) {
-            this.eventTarget = target;
             this.calculatePosition();
             this.host.togglePopover(force);
             this.toggleTimeoutId = null;
@@ -2829,27 +2893,11 @@ const PostPopovercontainer = /*@__PURE__*/ proxyCustomElement(class PostPopoverc
         this.toggleTimeoutId = window.setTimeout(() => (this.toggleTimeoutId = null), 10);
         const isOpen = e.newState === 'open';
         if (isOpen) {
-            const content = this.host.querySelector('.popover-content');
-            this.startAutoupdates();
-            if (content && this.animation === 'pop-in') {
-                popIn(content);
-            }
-            if (this.safeSpace)
-                window.addEventListener('mousemove', this.mouseTrackingHandler.bind(this));
-            // Emit event with `first` flag only true on the first open
-            if (this.firstOpen) {
-                this.postToggle.emit({ isOpen, first: this.firstOpen });
-                this.firstOpen = false;
-                return;
-            }
+            this.open();
         }
         else {
-            if (typeof this.clearAutoUpdate === 'function')
-                this.clearAutoUpdate();
-            if (this.safeSpace)
-                window.removeEventListener('mousemove', this.mouseTrackingHandler.bind(this));
+            this.close();
         }
-        this.postToggle.emit({ isOpen: isOpen, first: false });
     }
     /**
      * Start listening for DOM updates, scroll events etc. that have
@@ -2980,9 +3028,9 @@ const PostPopovercontainer = /*@__PURE__*/ proxyCustomElement(class PostPopoverc
         }
     }
     render() {
-        return (h(Host, { key: '493d032d16ace815b6c031e77dbcc673f26d149b', "data-version": version, popover: this.manualClose ? 'manual' : 'auto' }, h("div", { key: '97bb357cada0456b3aa458e12768d9ad5458ef24', class: "popover-content" }, this.arrow && (h("span", { key: 'f5f2256470edad5a8ca89c32b3a44ef0fe388eea', class: "arrow", ref: el => {
+        return (h(Host, { key: 'cdb25a25fbd5e411e380175a8d3789cec83e2755', "data-version": version, popover: this.manualClose ? 'manual' : 'auto' }, h("div", { key: 'e99bcc4d5123b335b4b8be7044a80b2913ab6fce', class: "popover-content" }, this.arrow && (h("span", { key: '3c228829cc7e5bd83d7f1759ef163407ebcd10c5', class: "arrow", ref: el => {
                 this.arrowRef = el;
-            } })), h("slot", { key: 'f259b6ad624cf392e0d41026b4eab586009cb3c7' }))));
+            } })), h("slot", { key: '6a213deed5ccfec47d4dee903c7544d30a3f5748' }))));
     }
     get host() { return this; }
     static get watchers() { return {
@@ -2999,6 +3047,8 @@ const PostPopovercontainer = /*@__PURE__*/ proxyCustomElement(class PostPopoverc
         "manualClose": [4, "manual-close"],
         "safeSpace": [513, "safe-space"],
         "show": [64],
+        "open": [64],
+        "close": [64],
         "hide": [64],
         "toggle": [64]
     }, undefined, {

package/dist/components/post-rating.js

@@ -28,10 +28,6 @@ const PostRating$1 = /*@__PURE__*/ proxyCustomElement(class PostRating extends H
         this.postInput = createEvent(this, "postInput", 7);
         this.postChange = createEvent(this, "postChange", 7);
         this.hasChanged = false;
-        /**
-         * Defines a hidden label for the component.
-         */
-        this.label = 'Rating';
         /**
          * Defines the total amount of stars rendered in the component.
          */
@@ -101,13 +97,13 @@ const PostRating$1 = /*@__PURE__*/ proxyCustomElement(class PostRating extends H
         }
     }
     render() {
-        return (h(Host, { key: 'befb055aff44467d2da231043db28797f843c239', "data-version": version }, h("div", { key: 'c231944ad2638c2b69b6ae9e8ad92a962aa50139', role: "slider", class: "rating", tabindex: "0", "aria-label": this.label, "aria-valuemin": "0", "aria-valuemax": this.stars, "aria-valuenow": this.currentRating, "aria-valuetext": `${this.currentRating} out of ${this.stars}`, "aria-readonly": this.readonly ? 'true' : 'false', onKeyDown: this.keydownHandler, onBlur: this.blurHandler }, Array.from({ length: this.stars }).map((v, i) => (h("div", { key: `star-${v}`, "aria-hidden": "true", class: {
+        return (h(Host, { key: '9089061145d80c4791a56580d107d6fab88f1d6d', "data-version": version }, h("div", { key: '81f0ba286541aecf6ddfd2e2fa113526a02abdcd', role: "slider", class: "rating", tabindex: "0", "aria-label": this.label, "aria-valuemin": "0", "aria-valuemax": this.stars, "aria-valuenow": this.currentRating, "aria-valuetext": `${this.currentRating} / ${this.stars}`, "aria-readonly": this.readonly ? 'true' : 'false', onKeyDown: this.keydownHandler, onBlur: this.blurHandler }, Array.from({ length: this.stars }).map((v, i) => (h("div", { key: `star-${v}`, "aria-hidden": "true", class: {
                 'star': true,
                 'before-hover': i < this.hoveredIndex,
                 'active': i < Math.round(this.currentRating),
                 'hover': i === this.hoveredIndex,
                 'after-active': i > this.hoveredIndex && i < this.currentRating,
-            }, onClick: () => this.update(i + 1), onMouseEnter: e => this.hoverHandler(i, e), onMouseLeave: e => this.hoverHandler(i, e) }, h("post-icon", { name: "2062", class: "stroke" }), h("post-icon", { name: "2574", class: "fill" })))))));
+            }, onClick: () => this.update(i + 1), onMouseEnter: e => this.hoverHandler(i, e), onMouseLeave: e => this.hoverHandler(i, e) }, h("post-icon", { name: "favoritestar", class: "stroke" }), h("post-icon", { name: "favoritestar-solid", class: "fill" })))))));
     }
     get host() { return this; }
     static get watchers() { return {

package/dist/components/post-tab-header.js

@@ -19,7 +19,7 @@ const PostTabHeader$1 = /*@__PURE__*/ proxyCustomElement(class PostTabHeader ext
         this.tabId = `tab-${this.host.id || nanoid(6)}`;
     }
     render() {
-        return (h(Host, { key: '387d9db0111153ca4a7da1a9ad600daeafa3b7a1', id: this.tabId, role: "tab", "data-version": version, "aria-selected": "false", tabindex: "-1", class: "tab-title", slot: "tabs" }, h("slot", { key: '62126f05530776ca45b151b00834fa0c68c5b26e' })));
+        return (h(Host, { key: '5d9cfad4e62285e8b64a5f597e3d38d451dd493f', id: this.tabId, role: "tab", "data-version": version, "aria-selected": "false", tabindex: "-1", class: "tab-title", slot: "tabs" }, h("slot", { key: '679874586fb55510af17838ef73403c8b7a33ddc' })));
     }
     get host() { return this; }
     static get watchers() { return {

package/dist/components/post-tab-panel.js

@@ -21,7 +21,7 @@ const PostTabPanel$1 = /*@__PURE__*/ proxyCustomElement(class PostTabPanel exten
         this.panelId = `panel-${this.host.id || nanoid(6)}`;
     }
     render() {
-        return (h(Host, { key: '97ae92b05f495a63bd5ec5f57eb196fdf6772ca8', "data-version": version, id: this.panelId, role: "tabpanel" }, h("slot", { key: '8b36e0849fcd65662a27bc62ac29cec0d8db4f41' })));
+        return (h(Host, { key: '5d6c56e41ac61b10dd2560482bc5e4edab394742', "data-version": version, id: this.panelId, role: "tabpanel" }, h("slot", { key: 'ec7be772a0d3f883388742460c825dce0f0e44e8' })));
     }
     get host() { return this; }
     static get watchers() { return {

package/dist/components/post-tabs.js

@@ -167,7 +167,7 @@ const PostTabs$1 = /*@__PURE__*/ proxyCustomElement(class PostTabs extends HTMLE
         nextTab.focus();
     }
     render() {
-        return (h(Host, { key: 'eb30ee19d073caf4f32e255045eff58c0cb511f5', "data-version": version }, h("div", { key: '0920e0cbb6565ff8a9ff663e938291c050d6c93c', class: "tabs-wrapper", part: "tabs" }, h("div", { key: 'df3a5a698a77719b371879effba16e11709b2c22', class: "tabs", role: "tablist" }, h("slot", { key: 'e6c9592b39e999369eb1b6f43b08e7130872add9', name: "tabs", onSlotchange: () => this.enableTabs() }))), h("div", { key: '14cdae926ce10f854577de34b713c8e269568dbb', class: "tab-content", part: "content" }, h("slot", { key: 'f2aaff6a23f8dd2683963cb25c95d41953e708f5', onSlotchange: () => this.moveMisplacedTabs() }))));
+        return (h(Host, { key: '3e352bc059be99242f612a49bdea71fd065d67b0', "data-version": version }, h("div", { key: '34d608d7af834fd4fb3106ac3fb90100a9b73138', class: "tabs-wrapper", part: "tabs" }, h("div", { key: '102e75b53d3e485a185d391f84755142d8690de6', class: "tabs", role: "tablist" }, h("slot", { key: '03624f2944dfd37d3eb3403772d430a6e053e676', name: "tabs", onSlotchange: () => this.enableTabs() }))), h("div", { key: '8c7c956b831ef19fb093122ca35c14b5a015dad3', class: "tab-content", part: "content" }, h("slot", { key: '8fad35a2a6d26814f513c422b4fcbe98aae7bd22', onSlotchange: () => this.moveMisplacedTabs() }))));
     }
     get host() { return this; }
     static get style() { return postTabsCss; }

package/dist/components/post-togglebutton.js

@@ -29,7 +29,7 @@ const PostTogglebutton$1 = /*@__PURE__*/ proxyCustomElement(class PostTogglebutt
         this.host.addEventListener('keydown', (e) => this.handleKeydown(e));
     }
     render() {
-        return (h(Host, { key: '190c53c4bbada662698addcb288bcb50a8d179b3', "data-version": version, role: "button", tabindex: "0", "aria-pressed": this.toggled.toString() }, h("slot", { key: '544bf7d937386a6e65be75e249f3dcc080054d74' })));
+        return (h(Host, { key: 'f56832bfbfacc23923ac06d8455fffcdafa8a7ec', "data-version": version, role: "button", tabindex: "0", "aria-pressed": this.toggled.toString() }, h("slot", { key: '7adc9ed579b6badeb08c7599ceb95892d68f027f' })));
     }
     get host() { return this; }
     static get style() { return postTogglebuttonCss; }