@lmvz-ds/components 0.35.2 → 0.36.1

package/hydrate/index.mjs

@@ -5666,7 +5666,19 @@ const ariaAttributes = [
     'aria-valuenow',
     'aria-valuetext',
 ];
+const ariaHostMirrorAttributes = [
+    'aria-haspopup',
+    'aria-controls',
+    'aria-expanded',
+    'aria-activedescendant',
+    'aria-autocomplete',
+];
 
+function isInputElement(element) {
+    if (!element)
+        return false;
+    return ['INPUT', 'TEXTAREA', 'SELECT', 'LMVZ-INPUT', 'LMVZ-SELECT', 'LMVZ-DATEPICKER'].includes(element.tagName?.toUpperCase());
+}
 function isActionButton(element) {
     return ['LMVZ-BUTTON', 'BUTTON'].includes(element.tagName.toUpperCase());
 }
@@ -5852,7 +5864,7 @@ function getLmvzComponentMetaInfo(el, key) {
 function isFocusControllerHost(el) {
     return Boolean(getLmvzComponentMetaInfo(el, 'isFocusControllerHost'));
 }
-const defaultConfig = {
+const defaultConfig$1 = {
     orientation: 'both',
     enableHomeAndEnd: false,
     manageTabIndex: false,
@@ -5865,7 +5877,7 @@ class DirectionalFocusController {
     constructor(host, config = {}) {
         this.host = host;
         this.config = {
-            ...defaultConfig,
+            ...defaultConfig$1,
             ...config,
         };
     }
@@ -5894,6 +5906,8 @@ class DirectionalFocusController {
         this.applyFocusTarget(element, true);
     }
     handleKeydown = (event) => {
+        if (isInputElement(event.target))
+            return;
         const intent = this.getFocusIntent(event.key);
         if (!intent)
             return;
@@ -8781,7 +8795,7 @@ class LmvzCard {
 
 const checkmarkSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTMuNzUgMTIuNTYyNUw4LjgzMDc5IDE3LjYyNUwyMC40Mzc1IDYuMzc1IiBzdHJva2U9ImJsYWNrIiBzdHJva2Utd2lkdGg9IjEuNzUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgo8L3N2Zz4K';
 
-const lmvzCheckboxCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-checkbox-h {   display: inline-block;    --checkbox-box-size: var(--lmvz-global-s18, 18px);    --checkbox-border-radius: var(--lmvz-global-s4, 4px);     --checkbox-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --checkbox-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --checkbox-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --checkbox-border-color-checked: var(--lmvz-semantic-color-border-active, #0f8acc);   --checkbox-border-color-error: var(--lmvz-semantic-color-status-on-danger, #a31419);    --checkbox-wrapper-bg-hover: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --checkbox-wrapper-bg-checked: var(--lmvz-semantic-color-status-active, #f6fbfe);    --checkbox-ripple-bg: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);    --checkbox-checkmark-color: var(--lmvz-semantic-color-border-active, #0f8acc);    --checkbox-label-color: var(--lmvz-semantic-color-on-surface-primary, #000000);   --checkbox-label-color-checked: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --checkbox-helper-color: var(--lmvz-semantic-color-on-surface-secondary, #545454);   --checkbox-error-color: var(--lmvz-semantic-color-status-on-danger, #a31419);   --checkbox-focus-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4);    --checkbox-easing: var(--lmvz-global-easing-default, ease);   --checkbox-duration: 0.2s; } .pill.sc-lmvz-checkbox {   display: flex;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   padding-block: var(--lmvz-dimension-8-2, clamp(0.13rem, 0.03rem + 0.39vw, 0.5rem));   padding-inline: var(--lmvz-dimension-10-4, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   border-radius: var(--lmvz-semantic-border-radius-round, 999px);         text-decoration: none;   background-color: transparent;   transition: background-color var(--checkbox-duration) var(--checkbox-easing); } input.sc-lmvz-checkbox {   position: absolute;   opacity: 0;   width: var(--checkbox-box-size);   height: var(--checkbox-box-size);   margin: 0;   cursor: pointer;   z-index: 1; } .box.sc-lmvz-checkbox {   display: flex;   align-items: center;   justify-content: center;   width: var(--checkbox-box-size);   height: var(--checkbox-box-size);   background-color: var(--checkbox-bg);   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--checkbox-border-color);   border-radius: var(--checkbox-border-radius);   color: var(--checkbox-checkmark-color);   cursor: pointer;   transition:     border-color var(--checkbox-duration) var(--checkbox-easing),     background-color var(--checkbox-duration) var(--checkbox-easing);   pointer-events: none;   flex-shrink: 0; } .indicator.sc-lmvz-checkbox {   display: flex;   align-items: center;   justify-content: center;   line-height: 0; } .content.sc-lmvz-checkbox {   display: flex;   flex-direction: column;   overflow-wrap: break-word;   min-width: 0;   cursor: pointer; } label.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5 Router);   color: var(--checkbox-label-color);   transition: color var(--checkbox-duration) var(--checkbox-easing);   cursor: pointer; } .helper-text.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-sm, 400 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5 Router);      color: var(--checkbox-helper-color);   margin-block-start: 2px; } .error-text.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-sm, 400 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5 Router);   color: var(--checkbox-error-color);   display: block;   margin-block-start: 4px;   padding-inline: 10px; }  @media (hover: hover) {   .pill.sc-lmvz-checkbox:hover {     background-color: var(--checkbox-wrapper-bg-hover);   }    .pill.sc-lmvz-checkbox:hover .box.sc-lmvz-checkbox {     border-color: var(--checkbox-border-color-hover);   } }  [checked].sc-lmvz-checkbox-h .pill.sc-lmvz-checkbox {   background-color: var(--checkbox-wrapper-bg-checked); } [checked].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {   border-color: var(--checkbox-border-color-checked); } [checked].sc-lmvz-checkbox-h label.sc-lmvz-checkbox {   color: var(--checkbox-label-color-checked);    }  [error].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {   border-color: var(--checkbox-border-color-error); } [error].sc-lmvz-checkbox-h .helper-text.sc-lmvz-checkbox {   color: var(--checkbox-error-color); } [disabled].sc-lmvz-checkbox-h {   opacity: var(--lmvz-component-input-disabled-opacity, 40%);   pointer-events: none;    input,   label,   .box,   .content {     cursor: not-allowed;   } } .sc-lmvz-checkbox-h:focus-within .pill.sc-lmvz-checkbox {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); }  @media (forced-colors: active) {   .box.sc-lmvz-checkbox {     forced-color-adjust: auto;     border-color: ButtonText;     background-color: Field;   }    [checked].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {     border-color: Highlight;     background-color: Field;   }    .indicator.sc-lmvz-checkbox {     color: ButtonText;   }    [checked].sc-lmvz-checkbox-h .indicator.sc-lmvz-checkbox {     color: HighlightText;   }    .sc-lmvz-checkbox-h:focus-within .pill.sc-lmvz-checkbox {     outline-color: Highlight;     box-shadow: none;   } }`;
+const lmvzCheckboxCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-checkbox-h {   display: inline-block;    --checkbox-box-size: var(--lmvz-global-s18, 18px);    --checkbox-border-radius: var(--lmvz-global-s4, 4px);     --checkbox-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --checkbox-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --checkbox-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --checkbox-border-color-checked: var(--lmvz-semantic-color-border-active, #0f8acc);   --checkbox-border-color-error: var(--lmvz-semantic-color-status-on-danger, #a31419);    --checkbox-wrapper-bg-hover: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --checkbox-wrapper-bg-checked: var(--lmvz-semantic-color-status-active, #f6fbfe);    --checkbox-ripple-bg: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);    --checkbox-checkmark-color: var(--lmvz-semantic-color-border-active, #0f8acc);    --checkbox-label-color: var(--lmvz-semantic-color-on-surface-primary, #000000);   --checkbox-label-color-checked: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --checkbox-helper-color: var(--lmvz-semantic-color-on-surface-secondary, #545454);   --checkbox-error-color: var(--lmvz-semantic-color-status-on-danger, #a31419);   --checkbox-focus-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4);    --checkbox-easing: var(--lmvz-global-easing-default, ease);   --checkbox-duration: 0.2s; } .pill.sc-lmvz-checkbox {   display: flex;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   padding-block: var(--lmvz-dimension-8-2, clamp(0.13rem, 0.03rem + 0.39vw, 0.5rem));   padding-inline: var(--lmvz-dimension-10-4, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   border-radius: var(--lmvz-semantic-border-radius-round, 999px);         text-decoration: none;   background-color: transparent;   transition: background-color var(--checkbox-duration) var(--checkbox-easing); } input.sc-lmvz-checkbox {   position: absolute;   opacity: 0;   width: var(--checkbox-box-size);   height: var(--checkbox-box-size);   margin: 0;   cursor: pointer;   z-index: 1;   appearance: none; } .box.sc-lmvz-checkbox {   display: flex;   align-items: center;   justify-content: center;   width: var(--checkbox-box-size);   height: var(--checkbox-box-size);   background-color: var(--checkbox-bg);   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--checkbox-border-color);   border-radius: var(--checkbox-border-radius);   color: var(--checkbox-checkmark-color);   cursor: pointer;   transition:     border-color var(--checkbox-duration) var(--checkbox-easing),     background-color var(--checkbox-duration) var(--checkbox-easing);   pointer-events: none;   flex-shrink: 0; } .indicator.sc-lmvz-checkbox {   display: flex;   align-items: center;   justify-content: center;   line-height: 0; } .content.sc-lmvz-checkbox {   display: flex;   flex-direction: column;   overflow-wrap: break-word;   min-width: 0;   cursor: pointer; } label.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5 Router);   color: var(--checkbox-label-color);   transition: color var(--checkbox-duration) var(--checkbox-easing);   cursor: pointer; } .helper-text.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-sm, 400 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5 Router);      color: var(--checkbox-helper-color);   margin-block-start: 2px; } .error-text.sc-lmvz-checkbox {   font: var(--lmvz-typography-body-sm, 400 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5 Router);   color: var(--checkbox-error-color);   display: block;   margin-block-start: 4px;   padding-inline: 10px; }  @media (hover: hover) {   .pill.sc-lmvz-checkbox:hover {     background-color: var(--checkbox-wrapper-bg-hover);   }    .pill.sc-lmvz-checkbox:hover .box.sc-lmvz-checkbox {     border-color: var(--checkbox-border-color-hover);   } }  [checked].sc-lmvz-checkbox-h .pill.sc-lmvz-checkbox {   background-color: var(--checkbox-wrapper-bg-checked); } [checked].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {   border-color: var(--checkbox-border-color-checked); } [checked].sc-lmvz-checkbox-h label.sc-lmvz-checkbox {   color: var(--checkbox-label-color-checked);    }  [error].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {   border-color: var(--checkbox-border-color-error); } [error].sc-lmvz-checkbox-h .helper-text.sc-lmvz-checkbox {   color: var(--checkbox-error-color); } [disabled].sc-lmvz-checkbox-h {   opacity: var(--lmvz-component-input-disabled-opacity, 40%);   pointer-events: none;    input,   label,   .box,   .content {     cursor: not-allowed;   } }  .sc-lmvz-checkbox-h:has(:focus-visible) .pill.sc-lmvz-checkbox {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); }  @media (forced-colors: active) {   .box.sc-lmvz-checkbox {     forced-color-adjust: auto;     border-color: ButtonText;     background-color: Field;   }    [checked].sc-lmvz-checkbox-h .box.sc-lmvz-checkbox {     border-color: Highlight;     background-color: Field;   }    .indicator.sc-lmvz-checkbox {     color: ButtonText;   }    [checked].sc-lmvz-checkbox-h .indicator.sc-lmvz-checkbox {     color: HighlightText;   }    .sc-lmvz-checkbox-h:has(:focus-visible) .pill.sc-lmvz-checkbox {     outline-color: Highlight;     box-shadow: none;   } }`;
 
 const CHECKMARK_SVG = toValidSvgStringWithFallback(checkmarkSvg);
 let checkboxIdCounter = 0;
@@ -8810,7 +8824,14 @@ class LmvzCheckbox extends ReactiveControllerHost {
     name;
     disabled = false;
     required = false;
-    error = false;
+    nativeError = false;
+    errorFromProp = false;
+    get error() {
+        return this.errorFromProp || this.nativeError;
+    }
+    set error(value) {
+        this.errorFromProp = value;
+    }
     errorMessage;
     helperText;
     form;
@@ -8819,6 +8840,10 @@ class LmvzCheckbox extends ReactiveControllerHost {
     handleCheckedChange(val) {
         this.checkedState = val;
         this.internals.setFormValue?.(val ? (this.value ?? 'on') : null);
+        this.updateValidity();
+    }
+    handleRequiredChange() {
+        this.updateValidity();
     }
     lmvzChange;
     async focusInput() {
@@ -8830,6 +8855,9 @@ class LmvzCheckbox extends ReactiveControllerHost {
     async reportValidity() {
         return this.internals?.reportValidity() ?? true;
     }
+    async getValidationMessage() {
+        return this.internals?.validationMessage ?? '';
+    }
     constructor(hostRef) {
         super();
         registerInstance(this, hostRef);
@@ -8849,10 +8877,15 @@ class LmvzCheckbox extends ReactiveControllerHost {
         this.initialChecked = this.checked;
         this.checkedState = this.checked;
         this.internals.setFormValue?.(this.checked ? (this.value ?? 'on') : null);
+        this.updateValidity();
         super.componentWillLoad();
     }
+    componentDidLoad() {
+        this.updateValidity();
+        super.componentDidLoad();
+    }
     componentWillRender() {
-        if (this.error && !this.errorMessage) {
+        if (this.errorFromProp && !this.errorMessage) {
             console.warn('lmvz-checkbox: error=true set without errorMessage — no visual-only error state is rendered. Provide errorMessage to communicate the error to users.');
         }
         super.componentWillRender();
@@ -8862,6 +8895,7 @@ class LmvzCheckbox extends ReactiveControllerHost {
     }
     formResetCallback() {
         this.checked = this.initialChecked;
+        this.updateValidity();
     }
     formStateRestoreCallback(state) {
         this.checked = state === (this.value ?? 'on');
@@ -8874,13 +8908,27 @@ class LmvzCheckbox extends ReactiveControllerHost {
     retargetInnerClicks() {
         this.nativeInput?.click();
     }
+    updateValidity() {
+        if (this.required && !this.checked) {
+            this.internals.setValidity?.({ valueMissing: true }, 'Please check this box.', this.nativeInput);
+            return;
+        }
+        this.internals.setValidity?.({});
+        this.nativeError = false;
+    }
+    handleInvalid() {
+        this.nativeError = true;
+    }
     render() {
-        return (hAsync(Host, { key: 'b6b4153dbf80af15cb15799889ca23b621b4ef73' }, hAsync("div", { key: 'f11d6baaa4b04ee74b201be8c4e125ccd5c366aa', class: "pill" }, hAsync("input", { key: 'd61dccfa163ecf4fffa95a5d44be35adbb8ee8ff', type: "checkbox", id: this.checkboxId, checked: this.checkedState, disabled: this.disabled, required: this.required, "aria-required": this.required ? 'true' : 'false', "aria-invalid": this.error ? 'true' : 'false', "aria-describedby": this.ariaDescribedBy, "aria-errormessage": this.error && this.errorId ? this.errorId : undefined, ref: (el) => (this.nativeInput = el), onChange: this.handleChange, autoFocus: this.autofocus }), hAsync("span", { key: '87d62f1e0572e174e6d15f30ff59e37f6a5333cb', class: "box", "aria-hidden": "true" }, this.checkedState && hAsync("span", { key: '74d29a32599f6c1ee8bde0cb6f27e384de7fcc2d', class: "indicator", innerHTML: CHECKMARK_SVG })), hAsync("span", { key: '544990c81b3f7f90b53902d580d2eb2197edfa8b', class: "content" }, hAsync("label", { key: '1884744656a280f85bec91b27315d3a6b70e8238', htmlFor: this.checkboxId }, this.label), this.helperText && (hAsync("span", { key: '6783ff413a884c78dbd52e07cc7b433f5a9dcf29', onClick: this.retargetInnerClicks.bind(this), class: "helper-text", id: this.helperId, role: "status" }, this.helperText)))), this.errorMessage && (hAsync("span", { key: '7c19fe406223a11e25df54cdfa304bc000eb421f', class: "error-text", id: this.errorId, role: "alert" }, this.errorMessage))));
+        return (hAsync(Host, { key: '089b23f8034fa089f358cc37923182c34f528cd2' }, hAsync("div", { key: '0af011ebf062332c330b49fa3076828204433ac4', class: "pill" }, hAsync("input", { key: 'a483a8c5bbe1d6da3cfab63ce32ad2e6392911ff', type: "checkbox", id: this.checkboxId, checked: this.checkedState, disabled: this.disabled, "aria-required": this.required ? 'true' : 'false', "aria-invalid": this.error ? 'true' : 'false', "aria-describedby": this.ariaDescribedBy, "aria-errormessage": this.error && this.errorId ? this.errorId : undefined, ref: (el) => (this.nativeInput = el), onChange: this.handleChange, autoFocus: this.autofocus }), hAsync("span", { key: 'f21d34ab625c7eef23bd2761b399e8770cd62275', class: "box", "aria-hidden": "true" }, this.checkedState && hAsync("span", { key: 'de2680ea17f34ab0124c529d88d4191c97d0a4c5', class: "indicator", innerHTML: CHECKMARK_SVG })), hAsync("span", { key: '1b2d24e43603033a5a77340164e002de326db11a', class: "content" }, hAsync("label", { key: 'b18f17abb4459b3783dc41d0031f4b26795fdcf5', htmlFor: this.checkboxId }, this.label), this.helperText && (hAsync("span", { key: 'f32591c55fcc88d130815780a9999fcb235afd88', onClick: this.retargetInnerClicks.bind(this), class: "helper-text", id: this.helperId, role: "status" }, this.helperText)))), this.errorMessage && (hAsync("span", { key: '076489f5baadab07d95fc787e9ac71bae0a6ab68', onClick: this.retargetInnerClicks.bind(this), class: "error-text", id: this.errorId, role: "alert" }, this.errorMessage))));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
         "checked": [{
                 "handleCheckedChange": 0
+            }],
+        "required": [{
+                "handleRequiredChange": 0
             }]
     }; }
     static get style() { return lmvzCheckboxCss(); }
@@ -8891,22 +8939,24 @@ class LmvzCheckbox extends ReactiveControllerHost {
             "label": [1],
             "checked": [1540],
             "value": [1],
-            "name": [1],
+            "name": [513],
             "disabled": [516],
             "required": [516],
-            "error": [516],
+            "error": [6660],
             "errorMessage": [1, "error-message"],
             "helperText": [1, "helper-text"],
             "form": [1],
             "autofocus": [4],
+            "nativeError": [32],
             "checkedState": [32],
             "focusInput": [64],
             "checkValidity": [64],
-            "reportValidity": [64]
+            "reportValidity": [64],
+            "getValidationMessage": [64]
         },
-        "$listeners$": undefined,
+        "$listeners$": [[0, "invalid", "handleInvalid"]],
         "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["checked", "checked"], ["disabled", "disabled"], ["required", "required"], ["error", "error"]]
+        "$attrsToReflect$": [["checked", "checked"], ["name", "name"], ["disabled", "disabled"], ["required", "required"], ["error", "error"]]
     }; }
 }
 
@@ -8986,12 +9036,2806 @@ class LmvzChip extends ReactiveControllerHost {
         "$flags$": 777,
         "$tagName$": "lmvz-chip",
         "$members$": {
-            "type": [1537],
-            "size": [1537]
+            "type": [1537],
+            "size": [1537]
+        },
+        "$listeners$": undefined,
+        "$lazyBundleId$": "-",
+        "$attrsToReflect$": [["type", "type"], ["size", "size"]]
+    }; }
+}
+
+// Low-Level
+const expectedPositive = (entityName, num) => `Non-positive ${entityName}: ${num}`;
+const expectedFinite = (entityName, num) => `Non-finite ${entityName}: ${num}`;
+const forbiddenBigIntToNumber = (entityName) => `Cannot convert bigint to ${entityName}`;
+const invalidObject = 'Invalid object';
+const numberOutOfRange = (entityName, val, min, max) => invalidEntity$1(entityName, val) + `; must be between ${min}-${max}`;
+// Entity/Fields/Bags
+const invalidEntity$1 = (fieldName, val) => `Invalid ${fieldName}: ${val}`;
+
+const nanoInMicro$1 = 1_000;
+const nanoInMilli$1 = 1_000_000;
+const nanoInSec$1 = 1_000_000_000;
+const nanoInMinute$1 = 60_000_000_000;
+const nanoInHour$1 = 3_600_000_000_000;
+function normalizeOptions(options) {
+    if (options === undefined) {
+        return Object.create(null);
+    }
+    return requireObjectLike(options);
+}
+function toFiniteNumber(arg, entityName = 'number') {
+    if (typeof arg === 'bigint') {
+        throw new TypeError(forbiddenBigIntToNumber(entityName));
+    }
+    arg = Number(arg);
+    if (!Number.isFinite(arg)) {
+        throw new RangeError(expectedFinite(entityName, arg));
+    }
+    return arg;
+}
+function toIntegerWithTrunc(arg, entityName) {
+    return Math.trunc(toFiniteNumber(arg, entityName)) || 0; // ensure no -0
+}
+function toPositiveIntegerWithTruncation(arg, entityName) {
+    return requireNumberIsPositive(toIntegerWithTrunc(arg, entityName), entityName);
+}
+/*
+Already known to be number.
+*/
+function requireNumberIsPositive(num, entityName = 'number') {
+    if (num <= 0) {
+        throw new RangeError(expectedPositive(entityName, num));
+    }
+    return num;
+}
+/*
+min/max are inclusive
+*/
+function constrainToRange$1(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+function isObjectLike(arg) {
+    return arg !== null && (typeof arg === 'object' || typeof arg === 'function');
+}
+function requireObjectLike(arg) {
+    if (!isObjectLike(arg)) {
+        throw new TypeError(invalidObject);
+    }
+    return arg;
+}
+
+const invalidEntity = invalidEntity$1;
+
+const missingField = fieldName => `Missing ${fieldName}`;
+
+const noValidFields = validFields => "No valid fields: " + validFields.join();
+
+const invalidChoice = (fieldName, val, choiceMap) => invalidEntity$1(fieldName, val) + "; must be " + Object.keys(choiceMap).join();
+
+const forbiddenValueOf$1 = "Cannot use valueOf";
+
+const invalidCallingContext = "Invalid calling context";
+
+const missingYear = allowEra => "Missing year" + (allowEra ? "/era/eraYear" : "");
+
+const invalidLeapMonth = "Invalid leap month";
+
+const exoticCalendarRequired = (calendarId, remedy) => `Unknown calendar ${calendarId}; might need ${remedy}`;
+
+const invalidTimeZone = calendarId => invalidEntity$1("TimeZone", calendarId);
+
+const outOfBoundsDate = "Out-of-bounds date";
+
+const failedParse = s => `Cannot parse: ${s}`;
+
+const invalidSubstring = substring => `Invalid substring: ${substring}`;
+
+const constrainToRange = constrainToRange$1;
+
+function throwRangeError(message) {
+  throw new RangeError(message);
+}
+
+function throwTypeError(message) {
+  throw new TypeError(message);
+}
+
+function clampProp(props, propName, min, max, overflow) {
+  return clampEntity(propName, ((props, propName) => {
+    const propVal = props[propName];
+    return void 0 === propVal && throwTypeError(missingField(propName)), propVal;
+  })(props, propName), min, max, overflow);
+}
+
+function clampEntity(entityName, num, min, max, overflow, choices) {
+  const clamped = constrainToRange(num, min, max);
+  return overflow && num !== clamped && throwRangeError(((entityName, val, min, max, choices) => numberOutOfRange(entityName, val, min, max))(entityName, num, min, max)), 
+  clamped;
+}
+
+function memoize(generator, MapClass = Map) {
+  const map = new MapClass;
+  return (key, ...otherArgs) => {
+    if (map.has(key)) {
+      return map.get(key);
+    }
+    const val = generator(key, ...otherArgs);
+    return map.set(key, val), val;
+  };
+}
+
+const createNameDescriptors = name => createPropDescriptors({
+  name: name
+});
+
+const createPropDescriptors = (propVals, readonly) => mapProps(value => ({
+  value: value,
+  configurable: 1,
+  writable: false
+}), propVals);
+
+const createStringTagDescriptors = value => ({
+  [Symbol.toStringTag]: {
+    value: value,
+    configurable: 1
+  }
+});
+
+function mapProps(transformer, props) {
+  const res = {};
+  for (const propName in props) {
+    res[propName] = transformer(props[propName], propName);
+  }
+  return res;
+}
+
+function zipPropsConst(propNames, propVal) {
+  const res = {};
+  for (const propName of propNames) {
+    res[propName] = propVal;
+  }
+  return res;
+}
+
+function createPropGetters(propNames) {
+  const getters = {};
+  for (const propName of propNames) {
+    getters[propName] = slots => slots[propName];
+  }
+  return getters;
+}
+
+function pluckProps(propNames, props, dest = Object.create(null)) {
+  for (const propName of propNames) {
+    dest[propName] = props[propName];
+  }
+  return dest;
+}
+
+function bindArgs(f, ...boundArgs) {
+  return (...dynamicArgs) => f(...boundArgs, ...dynamicArgs);
+}
+
+function noop() {}
+
+function capitalize(s) {
+  return s[0].toUpperCase() + s.substring(1);
+}
+
+function sortStrings(...strss) {
+  return [].concat(...strss).sort();
+}
+
+function createRegExp(meat) {
+  return new RegExp(`^${meat}$`, "i");
+}
+
+function parseSubsecNano(fracStr) {
+  return parseInt(fracStr.padEnd(9, "0"));
+}
+
+function parseSign(s) {
+  return s && "+" !== s ? -1 : 1;
+}
+
+function parseInt0(s) {
+  return void 0 === s ? 0 : parseInt(s);
+}
+
+function padNumber(digits, num) {
+  return String(num).padStart(digits, "0");
+}
+
+const padNumber2 = /*@__PURE__*/ bindArgs(padNumber, 2);
+
+function compareNumbers(a, b) {
+  return Math.sign(a - b);
+}
+
+function divFloorBigInt(num, denom) {
+  const whole = num / denom;
+  return num % denom < 0n ? whole - 1n : whole;
+}
+
+function divModFloorBigInt(num, divisor) {
+  const quotient = divFloorBigInt(num, divisor);
+  return [ quotient, num - quotient * divisor ];
+}
+
+function divModFloor(num, divisor) {
+  return [ Math.floor(num / divisor), modFloor(num, divisor) ];
+}
+
+function modFloor(num, divisor) {
+  return (num % divisor + divisor) % divisor;
+}
+
+function divTrunc(num, divisor) {
+  return Math.trunc(num / divisor) || 0;
+}
+
+function modTrunc(num, divisor) {
+  return num % divisor || 0;
+}
+
+const isoCalendarId = "iso8601";
+
+const gregoryCalendarId = "gregory";
+
+const gregoryEraOrigins = {
+  "bce": -1,
+  "ce": 0
+};
+
+function normalizeEraName(era) {
+  const normalized = era.normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, "");
+  return "bc" === normalized || "b" === normalized ? "bce" : "ad" === normalized || "a" === normalized ? "ce" : normalized;
+}
+
+const isoCalendarImpl = void 0;
+
+const gregoryCalendarImpl = 0;
+
+function getCalendarSlotId(calendar) {
+  return calendar === isoCalendarImpl ? "iso8601" : 0 === calendar ? "gregory" : calendar.id;
+}
+
+const monthCodeRegExp = /^M(\d{2})(L?)$/;
+
+function parseMonthCode(monthCode) {
+  const m = monthCodeRegExp.exec(monthCode);
+  return m || throwRangeError((monthCode => `Invalid monthCode: ${monthCode}`)(monthCode)), 
+  [ parseInt(m[1]), Boolean(m[2]) ];
+}
+
+function formatMonthCode(monthCodeNumber, isLeapMonth) {
+  return "M" + padNumber2(monthCodeNumber) + (isLeapMonth ? "L" : "");
+}
+
+function monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, leapMonth) {
+  return monthCodeNumber + (isLeapMonth || leapMonth && monthCodeNumber >= leapMonth ? 1 : 0);
+}
+
+const unitNameMap = {
+  nanosecond: 0,
+  microsecond: 1,
+  millisecond: 2,
+  second: 3,
+  minute: 4,
+  hour: 5,
+  day: 6,
+  week: 7,
+  month: 8,
+  year: 9
+};
+
+const unitNamesAsc = /*@__PURE__*/ Object.keys(unitNameMap);
+
+const nanoInMicro = nanoInMicro$1;
+
+const nanoInMilli = nanoInMilli$1;
+
+const nanoInSec = nanoInSec$1;
+
+const nanoInMinute = nanoInMinute$1;
+
+const nanoInHour = nanoInHour$1;
+
+const nanoInUtcDay = 864e11;
+
+const bigNanoInMicro = /*@__PURE__*/ BigInt(nanoInMicro);
+
+const bigNanoInMilli = /*@__PURE__*/ BigInt(nanoInMilli);
+
+const bigNanoInSec = /*@__PURE__*/ BigInt(nanoInSec);
+
+const bigNanoInMinute = /*@__PURE__*/ BigInt(nanoInMinute);
+
+const bigNanoInHour = /*@__PURE__*/ BigInt(nanoInHour);
+
+const bigNanoInUtcDay = /*@__PURE__*/ BigInt(nanoInUtcDay);
+
+const timeFieldNamesAsc = /*@__PURE__*/ unitNamesAsc.slice(0, 6);
+
+const yearFieldNamesAsc = [ "year" ];
+
+const dayFieldNamesAsc = [ "day" ];
+
+const calendarDateFieldNamesAsc = [ "day", "month", "year" ];
+
+const eraYearFieldNames = [ "era", "eraYear" ];
+
+const allYearFieldNames = [ "era", "eraYear", "year" ];
+
+const monthFieldNames = [ "month", "monthCode" ];
+
+const monthDayFieldNames = [ "day", "month", "monthCode" ];
+
+const yearMonthFieldNamesAlpha = /*@__PURE__*/ sortStrings(monthFieldNames, yearFieldNamesAsc);
+
+const yearMonthCodeFieldNamesAlpha = /*@__PURE__*/ sortStrings([ "monthCode" ], yearFieldNamesAsc);
+
+const yearMonthCodeFieldNamesWithEraAlpha = /*@__PURE__*/ sortStrings(eraYearFieldNames, yearMonthCodeFieldNamesAlpha);
+
+const dateFieldNamesAlpha = /*@__PURE__*/ sortStrings(dayFieldNamesAsc, yearMonthFieldNamesAlpha);
+
+const dateFieldNamesWithEraAlpha = /*@__PURE__*/ sortStrings(dayFieldNamesAsc, eraYearFieldNames, yearMonthFieldNamesAlpha);
+
+const yearMonthCodeDayFieldNamesAlpha = /*@__PURE__*/ sortStrings(dayFieldNamesAsc, yearMonthCodeFieldNamesAlpha);
+
+const yearMonthCodeDayFieldNamesWithEraAlpha = /*@__PURE__*/ sortStrings(dayFieldNamesAsc, eraYearFieldNames, yearMonthCodeFieldNamesAlpha);
+
+function validateTimeFields(timeFields) {
+  return constrainTimeFields(timeFields, 1), timeFields;
+}
+
+const maxValues = {
+  hour: 23,
+  minute: 59,
+  second: 59
+};
+
+function constrainTimeFields(timeFields, overflow) {
+  const constrainedFields = {};
+  for (const fieldName of timeFieldNamesAsc) {
+    constrainedFields[fieldName] = clampEntity(fieldName, timeFields[fieldName], 0, maxValues[fieldName] || 999, overflow);
+  }
+  return constrainedFields;
+}
+
+function timeFieldsToNano(timeFields) {
+  return timeFieldsToSec(timeFields) * nanoInSec + timeFieldsToSubsecNano(timeFields);
+}
+
+function timeFieldsToSec(timeFields) {
+  return 3600 * timeFields.hour + 60 * timeFields.minute + timeFields.second;
+}
+
+function timeFieldsToSubsecNano(timeFields) {
+  return timeFields.millisecond * nanoInMilli + timeFields.microsecond * nanoInMicro + timeFields.nanosecond;
+}
+
+function nanoToTimeAndDay(nano) {
+  const [dayDelta, timeNano] = divModFloor(nano, nanoInUtcDay);
+  return [ nanoToTimeFields(timeNano), dayDelta ];
+}
+
+function nanoToTimeFields(timeNano) {
+  const [timeMilli, nanoAfterMilli] = divModFloor(timeNano, nanoInMilli);
+  const [microsecond, nanosecond] = divModFloor(nanoAfterMilli, nanoInMicro);
+  return milliToTimeFields(timeMilli, microsecond, nanosecond);
+}
+
+function milliToTimeFields(timeMilli, microsecond = 0, nanosecond = 0) {
+  const [hour, milliAfterHour] = divModFloor(timeMilli, 36e5);
+  const [minute, milliAfterMinute] = divModFloor(milliAfterHour, 6e4);
+  const [second, millisecond] = divModFloor(milliAfterMinute, 1e3);
+  return {
+    hour: hour,
+    minute: minute,
+    second: second,
+    millisecond: millisecond,
+    microsecond: microsecond,
+    nanosecond: nanosecond
+  };
+}
+
+function epochNanoToSecMod(epochNano) {
+  const [epochSec, nano] = divModFloorBigInt(epochNano, bigNanoInSec);
+  return [ Number(epochSec), Number(nano) ];
+}
+
+function isoDateToEpochNano(isoDate) {
+  return BigInt(isoDateToEpochDays(isoDate)) * bigNanoInUtcDay;
+}
+
+function isoDateToEpochMilli(isoDate) {
+  return 864e5 * isoDateToEpochDays(isoDate);
+}
+
+function isoDateToEpochDays(isoDate) {
+  return isoArgsToEpochDays(isoDate.year, isoDate.month, isoDate.day);
+}
+
+function isoArgsToEpochDays(isoYear, isoMonth = 1, isoDay = 1) {
+  const monthIndex = isoMonth - 1;
+  return isoYear += Math.floor(monthIndex / 12), isoMonth = modFloor(monthIndex, 12), 
+  Date.UTC(isoYear % 400 - 400, isoMonth, 0) / 864e5 + 146097 * (divTrunc(isoYear, 400) + 1) + isoDay;
+}
+
+function epochNanoToIsoDateTime(epochNano) {
+  const [epochDays, nanoAfterDay] = divModFloorBigInt(epochNano, bigNanoInUtcDay);
+  return {
+    ...epochDaysToIsoDate(Number(epochDays)),
+    ...nanoToTimeFields(Number(nanoAfterDay))
+  };
+}
+
+function epochDaysToIsoDate(epochDays) {
+  const legacyDate = new Date(864e5 * modFloor(epochDays, 146097));
+  return {
+    year: legacyDate.getUTCFullYear() + 400 * Math.floor(epochDays / 146097),
+    month: legacyDate.getUTCMonth() + 1,
+    day: legacyDate.getUTCDate()
+  };
+}
+
+function computeIsoMonthCodeParts(month) {
+  return [ month, 0 ];
+}
+
+function computeIsoFieldsFromParts(year, month, day) {
+  return {
+    year: year,
+    month: month,
+    day: day
+  };
+}
+
+function computeIsoDaysInMonth(year, month) {
+  switch (month) {
+   case 2:
+    return computeIsoInLeapYear(year) ? 29 : 28;
+
+   case 4:
+   case 6:
+   case 9:
+   case 11:
+    return 30;
+  }
+  return 31;
+}
+
+function computeIsoDaysInYear(year) {
+  return computeIsoInLeapYear(year) ? 366 : 365;
+}
+
+function computeIsoInLeapYear(year) {
+  return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+}
+
+function addIsoMonths(year, month, monthDelta) {
+  return year += divTrunc(monthDelta, 12), (month += modTrunc(monthDelta, 12)) < 1 ? (year--, 
+  month += 12) : month > 12 && (year++, month -= 12), {
+    year: year,
+    month: month
+  };
+}
+
+function computeIsoDayOfWeek(isoDateFields) {
+  return modFloor(isoArgsToEpochDays(isoDateFields.year, isoDateFields.month, isoDateFields.day) + 4, 7) || 7;
+}
+
+function computeIsoDayOfYear(isoDateFields) {
+  return isoArgsToEpochDays(isoDateFields.year, isoDateFields.month, isoDateFields.day) - isoArgsToEpochDays(isoDateFields.year) + 1;
+}
+
+function computeIsoWeekFields(isoDateFields) {
+  let yearOfWeek = isoDateFields.year;
+  let weekOfYear = Math.floor((computeIsoDayOfYear(isoDateFields) - computeIsoDayOfWeek(isoDateFields) + 10) / 7);
+  let weeksInYear = computeIsoWeeksInYear(yearOfWeek);
+  return weekOfYear < 1 ? weekOfYear = weeksInYear = computeIsoWeeksInYear(--yearOfWeek) : weekOfYear > weeksInYear && (weekOfYear = 1, 
+  weeksInYear = computeIsoWeeksInYear(++yearOfWeek)), {
+    weekOfYear: weekOfYear,
+    yearOfWeek: yearOfWeek,
+    Ie: weeksInYear
+  };
+}
+
+function computeIsoWeeksInYear(year) {
+  const y0DayOfWeek = computeIsoDayOfWeek({
+    year: year,
+    month: 1,
+    day: 1
+  });
+  return 4 === y0DayOfWeek || 3 === y0DayOfWeek && computeIsoInLeapYear(year) ? 53 : 52;
+}
+
+function computeGregoryEraFields({year: year}) {
+  return year < 1 ? {
+    era: "bce",
+    eraYear: 1 - year
+  } : {
+    era: "ce",
+    eraYear: year
+  };
+}
+
+function validateIsoDateTimeFields(isoDateTime) {
+  return validateIsoDateFields(isoDateTime), validateTimeFields(isoDateTime);
+}
+
+function validateIsoDateFields(isoInternals) {
+  return constrainIsoDateFields(isoInternals, 1), isoInternals;
+}
+
+function constrainIsoDateFields(isoDate, overflow) {
+  const {year: year} = isoDate;
+  const month = clampProp(isoDate, "month", 1, 12, overflow);
+  return {
+    year: year,
+    month: month,
+    day: clampProp(isoDate, "day", 1, computeIsoDaysInMonth(year, month), overflow)
+  };
+}
+
+function computeCalendarDateFields(calendar, isoDate) {
+  return calendar ? calendar.ie(isoDate) : isoDate;
+}
+
+function computeCalendarMonthCodeParts(calendar, year, month) {
+  return calendar ? calendar.O(year, month) : computeIsoMonthCodeParts(month);
+}
+
+function computeCalendarEraFields(calendar, isoDate) {
+  return 0 === calendar ? computeGregoryEraFields(isoDate) : calendar ? calendar.h(isoDate) : {};
+}
+
+function computeCalendarIsoFieldsFromParts(calendar, year, month, day) {
+  return calendar ? calendar.je(year, month, day) : computeIsoFieldsFromParts(year, month, day);
+}
+
+function computeCalendarMonthsInYearForYear(calendar, year) {
+  return calendar ? calendar.k(year) : 12;
+}
+
+function computeCalendarDaysInMonthForYearMonth(calendar, year, month) {
+  return calendar ? calendar.p(year, month) : computeIsoDaysInMonth(year, month);
+}
+
+function computeCalendarMonthCode(calendar, isoDate) {
+  const {year: year, month: month} = computeCalendarDateFields(calendar, isoDate);
+  const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
+  return formatMonthCode(monthCodeNumber, isLeapMonth);
+}
+
+function computeCalendarInLeapYear(calendar, isoDate) {
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  return calendar ? calendar.u(year) : computeIsoInLeapYear(year);
+}
+
+function computeCalendarMonthsInYear(calendar, isoDate) {
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  return computeCalendarMonthsInYearForYear(calendar, year);
+}
+
+function computeCalendarDaysInMonth(calendar, isoDate) {
+  const {year: year, month: month} = computeCalendarDateFields(calendar, isoDate);
+  return computeCalendarDaysInMonthForYearMonth(calendar, year, month);
+}
+
+function computeCalendarDaysInYear(calendar, isoDate) {
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  return calendar ? calendar.j(year) : computeIsoDaysInYear(year);
+}
+
+function computeCalendarDayOfYear(calendar, isoDate) {
+  if (!calendar) {
+    return computeIsoDayOfYear(isoDate);
+  }
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  const yearStartIsoDate = computeCalendarIsoFieldsFromParts(calendar, year, 1, 1);
+  return isoDateToEpochDays(isoDate) - isoDateToEpochDays(yearStartIsoDate) + 1;
+}
+
+function computeCalendarWeekOfYear(calendar, isoDate) {
+  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).weekOfYear : void 0;
+}
+
+function computeCalendarYearOfWeek(calendar, isoDate) {
+  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).yearOfWeek : void 0;
+}
+
+const durationFieldNamesAsc = /*@__PURE__*/ unitNamesAsc.map(unitName => unitName + "s");
+
+const durationDateFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(6);
+
+const durationCalendarFieldNamesAsc = /*@__PURE__*/ durationDateFieldNamesAsc.slice(1);
+
+const durationFieldDefaults = /*@__PURE__*/ zipPropsConst(durationFieldNamesAsc, 0);
+
+const requireString = /*@__PURE__*/ bindArgs(requireType, "string");
+
+function requireType(typeName, arg, entityName = typeName) {
+  return typeof arg !== typeName && throwTypeError(invalidEntity(entityName, arg)), 
+  arg;
+}
+
+function requireNumberIsInteger(num, entityName = "number") {
+  return Number.isInteger(num) || throwRangeError(((entityName, num) => `Non-integer ${entityName}: ${num}`)(entityName, num)), 
+  num || 0;
+}
+
+function toString$4(arg) {
+  return "symbol" == typeof arg && throwTypeError("Cannot convert Symbol to string"), 
+  String(arg);
+}
+
+function toStringViaPrimitive(arg, entityName) {
+  return isObjectLike(arg) ? String(arg) : requireString(arg, entityName);
+}
+
+function toStrictInteger(arg, entityName) {
+  return requireNumberIsInteger(toFiniteNumber(arg, entityName), entityName);
+}
+
+const overflowMap = {
+  constrain: 0,
+  reject: 1
+};
+
+const calendarDisplayMap = {
+  auto: 0,
+  never: 1,
+  critical: 2,
+  always: 3
+};
+
+function coerceChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
+  const enumArg = options[optionName];
+  if (void 0 === enumArg) {
+    return defaultChoice;
+  }
+  const enumStr = toString$4(enumArg);
+  const enumNum = enumNameMap[enumStr];
+  return void 0 === enumNum && throwRangeError(invalidChoice(optionName, enumStr, enumNameMap)), 
+  enumNum;
+}
+
+const coerceOverflow = /*@__PURE__*/ bindArgs(coerceChoiceOption, "overflow", overflowMap);
+
+const coerceCalendarDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "calendarName", calendarDisplayMap);
+
+function combineDateAndTime(isoDate, time) {
+  return pluckProps(calendarDateFieldNamesAsc, isoDate, pluckProps(timeFieldNamesAsc, time));
+}
+
+function refineOverflowOptions(options) {
+  return void 0 === options ? 0 : coerceOverflow(requireObjectLike(options));
+}
+
+const epochNanoMax = /*@__PURE__*/ BigInt(1e8) * bigNanoInUtcDay;
+
+const epochNanoMin = /*@__PURE__*/ BigInt(-1e8) * bigNanoInUtcDay;
+
+const plainDateEpochNanoMin = epochNanoMin - bigNanoInUtcDay;
+
+const isoYearMonthIndexMin = -3261848;
+
+function checkIsoYearMonthInBounds(isoDate) {
+  const isoYearMonthIndex = 12 * isoDate.year + isoDate.month;
+  return (isoYearMonthIndex < isoYearMonthIndexMin || isoYearMonthIndex > 3309129) && throwRangeError(outOfBoundsDate), 
+  isoDate;
+}
+
+function checkIsoDateInBounds(isoDate, allowPlainDateLowerEdge = 1) {
+  return checkIsoDateEpochNanoInBounds(isoDateToEpochNano(isoDate), allowPlainDateLowerEdge), 
+  isoDate;
+}
+
+function checkIsoDateTimeInBounds(isoDateTime) {
+  const epochNano = isoDateToEpochNano(isoDateTime);
+  return checkIsoDateEpochNanoInBounds(epochNano), epochNano !== plainDateEpochNanoMin || timeFieldsToNano(isoDateTime) || throwRangeError(outOfBoundsDate), 
+  isoDateTime;
+}
+
+function checkIsoDateEpochNanoInBounds(epochNano, allowPlainDateLowerEdge = 1) {
+  (epochNano < (allowPlainDateLowerEdge ? plainDateEpochNanoMin : epochNanoMin) || epochNano > epochNanoMax) && throwRangeError(outOfBoundsDate);
+}
+
+function checkEpochNanoInBounds(epochNano) {
+  return (epochNano < epochNanoMin || epochNano > epochNanoMax) && throwRangeError(outOfBoundsDate), 
+  epochNano;
+}
+
+function isoDateTimeAndOffsetToEpochNano(isoDateTime, offsetNano) {
+  return checkEpochNanoInBounds(isoDateToEpochNano(isoDateTime) + BigInt(timeFieldsToNano(isoDateTime) - offsetNano));
+}
+
+function createDateSlots(isoDate, calendar) {
+  return pluckProps(calendarDateFieldNamesAsc, isoDate, {
+    calendar: calendar
+  });
+}
+
+function createDurationSlots(durationFields) {
+  return pluckProps(durationFieldNamesAsc, durationFields, {
+    sign: computeDurationSign(durationFields)
+  });
+}
+
+function moveYearMonth(doSubtract, calendar, isoDateFields, durationSlots, options) {
+  const overflow = refineOverflowOptions(options);
+  durationSlots.sign && getMaxDurationUnit(durationSlots) < 8 && throwRangeError("Cannot use small units");
+  const startOfMonthFields = checkIsoDateInBounds(moveToStartOfMonth(calendar, isoDateFields));
+  return moveToStartOfMonth(calendar, dateAddWithOverflow(calendar, startOfMonthFields, durationSlots, overflow));
+}
+
+function moveToStartOfMonth(calendar, isoDateFields) {
+  return moveByDays(isoDateFields, 1 - computeCalendarDateFields(calendar, isoDateFields).day);
+}
+
+function moveByDays(isoDate, days) {
+  return days ? epochDaysToIsoDate(isoDateToEpochDays(isoDate) + days) : isoDate;
+}
+
+function dateAddWithOverflow(calendar, isoDateFields, durationFields, overflow) {
+  let {years: years, months: months, weeks: weeks, days: days} = durationFields;
+  let isoDate;
+  if (days += Number(durationTimeToBigNano(durationFields) / bigNanoInUtcDay), years || months) {
+    isoDate = addDateMonths(calendar, isoDateFields, years, months, overflow);
+  } else {
+    if (!weeks && !days) {
+      return isoDateFields;
+    }
+    isoDate = isoDateFields;
+  }
+  return (weeks || days) && (isoDate = moveByDays(isoDate, 7 * weeks + days)), checkIsoDateInBounds(isoDate);
+}
+
+function addDateMonths(calendar, isoDateFields, years, months, overflow) {
+  const dateParts = computeCalendarDateFields(calendar, isoDateFields);
+  let {year: year, month: month, day: day} = dateParts;
+  if (years) {
+    const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
+    year += years, month = computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.q(year) : void 0, overflow), 
+    month = clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
+  }
+  if (months) {
+    const yearMonthParts = calendar ? calendar.N(year, month, months) : addIsoMonths(year, month, months);
+    ({year: year, month: month} = yearMonthParts);
+  }
+  return day = clampEntity("day", day, 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow), 
+  computeCalendarIsoFieldsFromParts(calendar, year, month, day);
+}
+
+function computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, targetLeapMonth, overflow) {
+  if (isLeapMonth) {
+    const leapMonthMeta = calendar ? calendar.m : void 0;
+    return void 0 !== targetLeapMonth && (leapMonthMeta < 0 || targetLeapMonth === monthCodeNumber + 1) ? targetLeapMonth : (1 === overflow && throwRangeError(invalidLeapMonth), 
+    leapMonthMeta < 0 ? -leapMonthMeta : monthCodeNumber);
+  }
+  return monthCodeNumberToMonth(monthCodeNumber, 0, targetLeapMonth);
+}
+
+function computeDurationSign(fields, fieldNames = durationFieldNamesAsc) {
+  let sign = 0;
+  for (const fieldName of fieldNames) {
+    const fieldSign = Math.sign(fields[fieldName]);
+    fieldSign && (sign && sign !== fieldSign && throwRangeError("Cannot mix duration signs"), 
+    sign = fieldSign);
+  }
+  return sign;
+}
+
+function validateDurationFields(fields) {
+  for (const calendarUnit of durationCalendarFieldNamesAsc) {
+    clampEntity(calendarUnit, fields[calendarUnit], -4294967295, 4294967295, 1);
+  }
+  const bigNano = durationDayTimeToBigNano(fields);
+  return validateDurationTimeUnit(Number(bigNano / bigNanoInSec)), fields;
+}
+
+function validateDurationTimeUnit(n) {
+  Number.isSafeInteger(n) || throwRangeError("Out-of-bounds duration");
+}
+
+function durationDayTimeToBigNano(fields) {
+  return BigInt(fields.days) * bigNanoInUtcDay + durationTimeToBigNano(fields);
+}
+
+function durationTimeToBigNano(fields) {
+  return BigInt(fields.hours) * bigNanoInHour + BigInt(fields.minutes) * bigNanoInMinute + durationSubMinuteToBigNano(fields);
+}
+
+function durationSubMinuteToBigNano(fields) {
+  return BigInt(fields.seconds) * bigNanoInSec + BigInt(fields.milliseconds) * bigNanoInMilli + BigInt(fields.microseconds) * bigNanoInMicro + BigInt(fields.nanoseconds);
+}
+
+function getMaxDurationUnit(fields) {
+  let unit = 9;
+  for (;unit > 0 && !fields[durationFieldNamesAsc[unit]]; unit--) {}
+  return unit;
+}
+
+function compareIsoDateFields(isoFields0, isoFields1) {
+  return compareNumbers(isoDateToEpochDays(isoFields0), isoDateToEpochDays(isoFields1));
+}
+
+function getCalendarEraOrigins(calendar) {
+  return 0 === calendar ? gregoryEraOrigins : calendar ? calendar.l : void 0;
+}
+
+function getCalendarFieldNames(calendar, fieldNames, fieldNamesWithEra = fieldNames) {
+  return getCalendarEraOrigins(calendar) ? fieldNamesWithEra : fieldNames;
+}
+
+function resolveCalendarYear(calendar, fields) {
+  const exoticCalendar = calendar || void 0;
+  const eraOrigins = getCalendarEraOrigins(calendar);
+  let {era: era, eraYear: eraYear, year: year} = fields;
+  if (void 0 !== year && (year = toIntegerWithTrunc(year, "year")), void 0 !== eraYear && (eraYear = toIntegerWithTrunc(eraYear, "eraYear")), 
+  void 0 !== era || void 0 !== eraYear) {
+    void 0 !== era && void 0 !== eraYear || throwTypeError("Mismatching era/eraYear"), 
+    eraOrigins || throwRangeError("Forbidden era/eraYear");
+    const normalizedEra = normalizeEraName(era);
+    const eraOrigin = eraOrigins[normalizedEra];
+    void 0 === eraOrigin && throwRangeError((era => `Invalid era: ${era}`)(era));
+    const yearByEra = exoticCalendar?.te ? exoticCalendar.te(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
+    void 0 !== year && year !== yearByEra && throwRangeError("Mismatching year/eraYear"), 
+    year = yearByEra;
+  } else {
+    void 0 === year && throwTypeError(missingYear(eraOrigins));
+  }
+  return year;
+}
+
+function resolveCalendarMonth(calendar, fields, year, overflow, monthCodeParts) {
+  let {month: month, monthCode: monthCode} = fields;
+  if (void 0 !== monthCode) {
+    const monthByCode = ((calendar, monthCode, year, overflow, monthCodeParts = parseMonthCode(monthCode)) => {
+      const leapMonth = calendar ? calendar.q(year) : void 0;
+      const [monthCodeNumber, wantsLeapMonth] = monthCodeParts;
+      let month = monthCodeNumberToMonth(monthCodeNumber, wantsLeapMonth, leapMonth);
+      if (wantsLeapMonth) {
+        const leapMonthMeta = calendar ? calendar.m : void 0;
+        void 0 === leapMonthMeta && throwRangeError(invalidLeapMonth), leapMonthMeta > 0 ? (month > leapMonthMeta && throwRangeError(invalidLeapMonth), 
+        leapMonth !== month && (1 === overflow && throwRangeError(invalidLeapMonth), month = monthCodeNumberToMonth(monthCodeNumber, 0, leapMonth))) : (month !== -leapMonthMeta && throwRangeError(invalidLeapMonth), 
+        void 0 === leapMonth && 1 === overflow && throwRangeError(invalidLeapMonth));
+      }
+      return month;
+    })(calendar, monthCode, year, overflow, monthCodeParts);
+    void 0 !== month && month !== monthByCode && throwRangeError("Mismatching month/monthCode"), 
+    month = monthByCode, overflow = 1;
+  } else {
+    void 0 === month && throwTypeError("Missing month/monthCode");
+  }
+  return clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
+}
+
+function resolveCalendarDay(calendar, fields, month, year, overflow) {
+  return clampProp(fields, "day", 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow);
+}
+
+function eraYearToYear(eraYear, eraOrigin) {
+  return (eraOrigin + eraYear) * (Math.sign(eraOrigin) || 1) || 0;
+}
+
+const offsetRegExp = /*@__PURE__*/ createRegExp("([+-])(\\d{2})(?::?(\\d{2})(?::?(\\d{2})(?:[.,](\\d{1,9}))?)?)?");
+
+function parseOffsetNanoMaybe(s, onlyHourMinute) {
+  const parts = offsetRegExp.exec(s);
+  if (parts && (s => (s => {
+    "T" !== s[0] && "t" !== s[0] || (s = s.slice(1));
+    const fractionIndex = s.search(/[.,]/);
+    const main = fractionIndex < 0 ? s : s.slice(0, fractionIndex);
+    const parts = main.split(":");
+    return 1 === parts.length ? /^(?:\d{2}|\d{4}|\d{6})$/i.test(main) : (2 === parts.length || 3 === parts.length) && parts.every(part => 2 === part.length && /^\d{2}$/i.test(part));
+  })(s.slice(1)))(parts[0])) {
+    return ((parts, onlyHourMinute) => {
+      const firstSubMinutePart = parts[4] || parts[5];
+      firstSubMinutePart && throwRangeError(invalidSubstring(firstSubMinutePart));
+      const offsetNanoPos = parseInt0(parts[2]) * nanoInHour + parseInt0(parts[3]) * nanoInMinute + parseInt0(parts[4]) * nanoInSec + parseSubsecNano(parts[5] || "");
+      return offsetNano = offsetNanoPos * parseSign(parts[1]), Math.abs(offsetNano) >= nanoInUtcDay && throwRangeError("Out-of-bounds offset"), 
+      offsetNano;
+      var offsetNano;
+    })(parts);
+  }
+}
+
+const dateFieldRefiners = {
+  era: toStringViaPrimitive,
+  month: toPositiveIntegerWithTruncation,
+  monthCode(monthCode, entityName = "monthCode") {
+    return ((monthCode, entityName) => {
+      if ("string" == typeof monthCode) {
+        return monthCode;
+      }
+      if (monthCode && "object" == typeof monthCode) {
+        const monthCodeToString = monthCode.toString;
+        if ("function" == typeof monthCodeToString) {
+          return requireString(monthCodeToString.call(monthCode), entityName);
+        }
+      }
+      return requireString(monthCode, entityName);
+    })(monthCode, entityName);
+  },
+  day: toPositiveIntegerWithTruncation
+};
+
+function readAndRefineBagFields(bag, validFieldNames, fieldRefiners, requiredFieldNames, disallowEmpty = !requiredFieldNames) {
+  const res = {};
+  let anyMatching = 0;
+  for (const fieldName of validFieldNames) {
+    let fieldVal = bag[fieldName];
+    if (void 0 !== fieldVal) {
+      anyMatching = 1;
+      const refiner = fieldRefiners[fieldName];
+      refiner && (fieldVal = refiner(fieldVal, fieldName)), res[fieldName] = fieldVal;
+    } else {
+      requiredFieldNames && requiredFieldNames.includes(fieldName) && throwTypeError(missingField(fieldName));
+    }
+  }
+  return disallowEmpty && !anyMatching && throwTypeError(noValidFields(validFieldNames)), 
+  res;
+}
+
+function createPlainDateFromFields(calendar, fields, options) {
+  return createPlainDateFromPreparedFields(calendar, fields, prepareDateFields(calendar, fields), refineOverflowOptions(options));
+}
+
+function createPlainDateFromPreparedFields(calendar, fields, prepared, overflow) {
+  const year = prepared[1];
+  const month = resolveCalendarMonth(calendar, fields, year, overflow, prepared[0]);
+  return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, resolveCalendarDay(calendar, fields, month, year, overflow))), calendar);
+}
+
+function parseMonthCodeField(fields) {
+  if (void 0 !== fields.monthCode) {
+    return parseMonthCode(fields.monthCode);
+  }
+}
+
+function prepareDateFields(calendar, fields) {
+  const eraOrigins = getCalendarEraOrigins(calendar);
+  return void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins)), 
+  void 0 === fields.monthCode && void 0 === fields.month && throwTypeError("Missing month/monthCode"), 
+  void 0 === fields.day && throwTypeError(missingField("day")), [ parseMonthCodeField(fields), resolveCalendarYear(calendar, fields) ];
+}
+
+function createPlainYearMonthFromFields(calendar, fields, options) {
+  const eraOrigins = getCalendarEraOrigins(calendar);
+  void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins)), 
+  void 0 === fields.monthCode && void 0 === fields.month && throwTypeError("Missing month/monthCode");
+  const monthCodeParts = parseMonthCodeField(fields);
+  const year = resolveCalendarYear(calendar, fields);
+  return createDateSlots(checkIsoYearMonthInBounds(computeCalendarIsoFieldsFromParts(calendar, year, resolveCalendarMonth(calendar, fields, year, refineOverflowOptions(options), monthCodeParts), 1)), calendar);
+}
+
+const RawDateTimeFormat = Intl.DateTimeFormat;
+
+function formatEpochMilliToPartsRecord(intlFormat, epochMilli) {
+  epochMilli < -864e13 && throwRangeError(outOfBoundsDate);
+  const parts = intlFormat.formatToParts(epochMilli);
+  const hash = {};
+  for (const part of parts) {
+    hash[part.type] = part.value;
+  }
+  return hash;
+}
+
+const timeZonePeriodDaysByName = {
+  "El_Aaiun": 17,
+  "Tucuman": 12,
+  "Tirane": 11,
+  "Riga": 10,
+  "Simferopol": 9,
+  "Vienna": 9,
+  "Tunis": 8,
+  "Boa_Vista": 6,
+  "Fortaleza": 6,
+  "Maceio": 6,
+  "Noronha": 6,
+  "Recife": 6,
+  "Gaza": 6,
+  "Hebron": 6,
+  "DeNoronha": 6
+};
+
+const minPossibleTransitionSec = -388152e4;
+
+function refineDateDisplayOptions(options) {
+  return coerceCalendarDisplay(normalizeOptions(options));
+}
+
+function formatPlainDateIso(plainDateSlots, options) {
+  return calendar = plainDateSlots.calendar, isoDate = plainDateSlots, calendarDisplay = refineDateDisplayOptions(options), 
+  formatIsoDateFields(isoDate) + formatCalendar(calendar, calendarDisplay);
+  var calendar, isoDate, calendarDisplay;
+}
+
+function formatDateIsoAuto(plainDateSlots) {
+  return formatIsoDateFields(plainDateSlots) + (plainDateSlots.calendar === isoCalendarImpl ? "" : formatCalendarId(getCalendarSlotId(plainDateSlots.calendar), 0));
+}
+
+function formatPlainYearMonthIso(plainYearMonthSlots, options) {
+  return formatDateLikeIso(plainYearMonthSlots.calendar, formatIsoYearMonthFields, plainYearMonthSlots, refineDateDisplayOptions(options));
+}
+
+function formatYearMonthIsoAuto(plainYearMonthSlots) {
+  const calendar = plainYearMonthSlots.calendar;
+  return calendar !== isoCalendarImpl ? formatIsoDateFields(plainYearMonthSlots) + formatCalendarId(getCalendarSlotId(calendar), 0) : formatIsoYearMonthFields(plainYearMonthSlots);
+}
+
+function formatDateLikeIso(calendar, formatSimple, isoDate, calendarDisplay) {
+  const showCalendar = calendarDisplay > 1 || 0 === calendarDisplay && calendar !== isoCalendarImpl;
+  return 1 === calendarDisplay ? calendar === isoCalendarImpl ? formatSimple(isoDate) : formatIsoDateFields(isoDate) : showCalendar ? formatIsoDateFields(isoDate) + formatCalendarId(getCalendarSlotId(calendar), 2 === calendarDisplay) : formatSimple(isoDate);
+}
+
+function formatIsoDateFields(isoDateFields) {
+  return formatIsoYearMonthFields(isoDateFields) + "-" + padNumber2(isoDateFields.day);
+}
+
+function formatIsoYearMonthFields(isoDateFields) {
+  const {year: year} = isoDateFields;
+  return (year < 0 || year > 9999 ? getSignStr(year) + padNumber(6, Math.abs(year)) : padNumber(4, year)) + "-" + padNumber2(isoDateFields.month);
+}
+
+function formatOffsetNano(offsetNano, offsetDisplay = 0) {
+  if (1 === offsetDisplay) {
+    return "";
+  }
+  const [hour, nanoRemainder0] = divModFloor(Math.abs(offsetNano), nanoInHour);
+  const [minute, nanoRemainder1] = divModFloor(nanoRemainder0, nanoInMinute);
+  const [second, nanoRemainder2] = divModFloor(nanoRemainder1, nanoInSec);
+  return getSignStr(offsetNano) + padNumber2(hour) + ":" + padNumber2(minute) + (second || nanoRemainder2 ? ":" + padNumber2(second) + formatSubsecNano(nanoRemainder2) : "");
+}
+
+function formatCalendar(calendar, calendarDisplay) {
+  return calendarDisplay > 1 || 0 === calendarDisplay && calendar !== isoCalendarImpl ? formatCalendarId(getCalendarSlotId(calendar), 2 === calendarDisplay) : "";
+}
+
+function formatCalendarId(calendarId, isCritical) {
+  return "[" + (isCritical ? "!" : "") + "u-ca=" + calendarId + "]";
+}
+
+const trailingZerosRE = /0+$/;
+
+function formatSubsecNano(totalNano, subsecDigits) {
+  let s = padNumber(9, totalNano);
+  return s = s.replace(trailingZerosRE, "") , 
+  s ? "." + s : "";
+}
+
+function getSignStr(num) {
+  return num < 0 ? "-" : "+";
+}
+
+const icuRegExp = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/;
+
+const badCharactersRegExp = /[^\w\/:+-]+/;
+
+function refineTimeZoneId(rawId) {
+  return resolveTimeZoneId(requireString(rawId));
+}
+
+function resolveTimeZoneId(rawId) {
+  return resolveTimeZoneRecord(rawId).id;
+}
+
+function resolveTimeZoneRecord(rawId) {
+  const upperRawId = rawId.toUpperCase();
+  const offsetRecord = (upperRawId => {
+    const offsetNano = parseOffsetNanoMaybe(upperRawId);
+    if (void 0 !== offsetNano) {
+      return {
+        id: formatOffsetNano(offsetNano),
+        _: offsetNano,
+        o: offsetNano
+      };
+    }
+  })(upperRawId);
+  if (offsetRecord) {
+    return {
+      kind: "fixed",
+      ...offsetRecord
+    };
+  }
+  const normId = "UTC" === upperRawId ? "UTC" : (rawId => (badCharactersRegExp.test(rawId) && throwRangeError(invalidTimeZone(rawId)), 
+  icuRegExp.test(rawId) && throwRangeError("Forbidden ICU TimeZone"), rawId.toLowerCase().split("/").map((part, partI) => (part.length <= 3 || /\d/.test(part)) && !/etc|yap/.test(part) ? part.toUpperCase() : part.replace(/baja|dumont|[a-z]+/g, (a, i) => a.length <= 2 && !partI || "in" === a || "chat" === a ? a.toUpperCase() : a.length > 2 || !i ? capitalize(a).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : a)).join("/")))(rawId);
+  return queryNamedTimeZoneRecord(normId);
+}
+
+const queryNamedTimeZoneRecord = /*@__PURE__*/ memoize(normId => {
+  if ("UTC" === normId) {
+    return {
+      kind: "utc",
+      id: normId,
+      o: normId
+    };
+  }
+  const upperNormId = normId.toUpperCase();
+  const format = queryTimeZoneIntlFormat(upperNormId);
+  return {
+    kind: "named",
+    id: normId,
+    format: format,
+    o: format.resolvedOptions().timeZone
+  };
+});
+
+const queryTimeZoneIntlFormat = /*@__PURE__*/ memoize(upperNormId => new RawDateTimeFormat("en-u-hc-h23", {
+  calendar: "iso8601",
+  timeZone: upperNormId,
+  era: "short",
+  year: "numeric",
+  month: "numeric",
+  day: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+}));
+
+function queryTimeZone(rawTimeZoneId) {
+  const record = resolveTimeZoneRecord(rawTimeZoneId);
+  return queryTimeZoneRecord(record.id, record);
+}
+
+const queryTimeZoneRecord = /*@__PURE__*/ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.o, record.format) : new FixedTimeZone(normTimeZoneId, record.o, "fixed" === record.kind ? record._ : 0));
+
+class FixedTimeZone {
+  constructor(id, compareKey, offsetNano) {
+    this.id = id, this.o = compareKey, this._ = offsetNano;
+  }
+  C() {
+    return this._;
+  }
+  R(isoDateTime) {
+    return [ isoDateTimeAndOffsetToEpochNano(isoDateTime, this._) ];
+  }
+  U() {}
+}
+
+class IntlTimeZone {
+  constructor(id, compareKey, format) {
+    this.id = id, this.o = compareKey, this.qe = ((computeOffsetSec, periodDays) => {
+      const getSample = memoize(computeOffsetSec);
+      const getSplit = memoize(createSplitTuple);
+      const periodSec = 86400 * periodDays;
+      function getOffsetSec(epochSec) {
+        const [startEpochSec, endEpochSec] = computePeriod(epochSec, periodSec);
+        const clampedStartEpochSec = clampIntlSampleEpochSec(startEpochSec);
+        const clampedEndEpochSec = clampIntlSampleEpochSec(endEpochSec);
+        const startOffsetSec = getSample(clampedStartEpochSec);
+        const endOffsetSec = getSample(clampedEndEpochSec);
+        return startOffsetSec === endOffsetSec ? startOffsetSec : pinch(getSplit(clampedStartEpochSec, clampedEndEpochSec), startOffsetSec, endOffsetSec, epochSec);
+      }
+      function pinch(split, startOffsetSec, endOffsetSec, forEpochSec) {
+        let offsetSec;
+        let splitDurSec;
+        for (;(void 0 === forEpochSec || void 0 === (offsetSec = forEpochSec < split[0] ? startOffsetSec : forEpochSec >= split[1] ? endOffsetSec : void 0)) && (splitDurSec = split[1] - split[0]); ) {
+          const middleEpochSec = split[0] + Math.floor(splitDurSec / 2);
+          computeOffsetSec(middleEpochSec) === endOffsetSec ? split[1] = middleEpochSec : split[0] = middleEpochSec + 1;
+        }
+        return offsetSec;
+      }
+      return {
+        Ee(zonedEpochSec) {
+          const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400);
+          const wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400);
+          const wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0;
+          const wideUtcEpochSec1 = zonedEpochSec - wideOffsetSec1;
+          if (wideOffsetSec0 === wideOffsetSec1) {
+            return [ wideUtcEpochSec0 ];
+          }
+          const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
+          return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [ zonedEpochSec - narrowOffsetSec0 ] : wideOffsetSec0 > wideOffsetSec1 ? [ wideUtcEpochSec0, wideUtcEpochSec1 ] : [];
+        },
+        De: getOffsetSec,
+        U: function getTransition(epochSec, direction) {
+          if (direction > 0 && epochSec >= 864e10) {
+            return;
+          }
+          if (direction < 0) {
+            if (epochSec <= minPossibleTransitionSec) {
+              return;
+            }
+            const lookaheadEpochSec = getCurrentEpochSec() + 94867200;
+            if (epochSec > lookaheadEpochSec) {
+              return getTransition(lookaheadEpochSec, -1);
+            }
+          }
+          const searchEpochSec = direction > 0 ? Math.max(epochSec, minPossibleTransitionSec) : epochSec;
+          let [startEpochSec, endEpochSec] = computePeriod(searchEpochSec, periodSec);
+          const inc = periodSec * direction;
+          const searchLimit = direction > 0 ? Math.max(epochSec, getCurrentEpochSec()) + 94867200 : minPossibleTransitionSec;
+          const inBounds = () => direction < 0 ? endEpochSec > searchLimit : startEpochSec < searchLimit;
+          for (;inBounds(); ) {
+            const clampedStartEpochSec = clampIntlSampleEpochSec(startEpochSec);
+            const clampedEndEpochSec = clampIntlSampleEpochSec(endEpochSec);
+            const startOffsetSec = getSample(clampedStartEpochSec);
+            const endOffsetSec = getSample(clampedEndEpochSec);
+            if (startOffsetSec !== endOffsetSec) {
+              const split = getSplit(clampedStartEpochSec, clampedEndEpochSec);
+              pinch(split, startOffsetSec, endOffsetSec);
+              const transitionEpochSec = split[0];
+              if ((compareNumbers(transitionEpochSec, epochSec) || 1) === direction) {
+                return transitionEpochSec;
+              }
+            }
+            startEpochSec += inc, endEpochSec += inc;
+          }
+        }
+      };
+    })((format => epochSec => {
+      const intlParts = formatEpochMilliToPartsRecord(format, 1e3 * epochSec);
+      return 86400 * isoArgsToEpochDays((intlParts => {
+        const relatedYear = intlParts.relatedYear;
+        if (void 0 !== relatedYear) {
+          return parseInt(relatedYear);
+        }
+        const year = parseInt(intlParts.year);
+        return void 0 !== intlParts.era && "bce" === normalizeEraName(intlParts.era) ? 1 - year : year;
+      })(intlParts), parseInt(intlParts.month), parseInt(intlParts.day)) + 3600 * parseInt(intlParts.hour) + 60 * parseInt(intlParts.minute) + parseInt(intlParts.second) - epochSec;
+    })(format), (timeZoneId => {
+      const timeZoneName = timeZoneId.split("/").pop();
+      return timeZonePeriodDaysByName[timeZoneName] || 60;
+    })(id));
+  }
+  C(epochNano) {
+    return this.qe.De((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
+  }
+  R(isoDateTime) {
+    const zonedEpochSec = 86400 * isoDateToEpochDays(isoDateTime) + timeFieldsToSec(isoDateTime);
+    const subsecNano = timeFieldsToSubsecNano(isoDateTime);
+    return this.qe.Ee(zonedEpochSec).map(epochSec => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
+  }
+  U(epochNano, direction) {
+    const [epochSec, subsecNano] = epochNanoToSecMod(epochNano);
+    const resEpochSec = this.qe.U(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
+    if (void 0 !== resEpochSec) {
+      return BigInt(resEpochSec) * bigNanoInSec;
+    }
+  }
+}
+
+function getCurrentEpochSec() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+function createSplitTuple(startEpochSec, endEpochSec) {
+  return [ startEpochSec, endEpochSec ];
+}
+
+function computePeriod(epochSec, periodSec) {
+  const startEpochSec = Math.floor(epochSec / periodSec) * periodSec;
+  return [ startEpochSec, startEpochSec + periodSec ];
+}
+
+function clampIntlSampleEpochSec(epochSec) {
+  return constrainToRange(epochSec, -1e10, 864e10);
+}
+
+function refinePlainDateObjectLike(calendar, bag, options, requireFields = []) {
+  return createPlainDateFromFields(calendar, readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha), dateFieldRefiners, requireFields), options);
+}
+
+function throwFailedParse(s) {
+  throwRangeError(failedParse(s));
+}
+
+function parsePlainDate(s, resolveCalendar) {
+  const slots = finalizeDateLike(parsePlainDateLike(requireString(s)), void 0, resolveCalendar);
+  return createDateSlots(slots, slots.calendar);
+}
+
+function parsePlainYearMonth(s, resolveCalendar) {
+  const organized = parseYearMonthOnly(requireString(s));
+  if (organized) {
+    return requireIsoCalendar(organized), createDateSlots(checkIsoYearMonthInBounds(validateIsoDateFields(organized)), resolveCalendar(organized.calendarId));
+  }
+  const dateSlots = finalizeDateLike(parsePlainDateLike(s), projectIsoYearMonthDate, resolveCalendar);
+  const {calendar: calendar} = dateSlots;
+  return createDateSlots(moveToStartOfMonth(calendar, dateSlots), calendar);
+}
+
+function requireIsoCalendar(organized) {
+  "iso8601" !== organized.calendarId && throwRangeError(invalidSubstring(organized.calendarId));
+}
+
+function parsePlainDateLike(s) {
+  const organized = parseDateTimeLike(s);
+  return organized && !organized.F || throwFailedParse(s), organized;
+}
+
+function finalizeDateLike(organized, isoDateProjector, resolveCalendar) {
+  return isoDateProjector && "iso8601" === organized.calendarId ? (validateIsoDateFields(organized), 
+  organized.fe && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.fe ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
+}
+
+function projectIsoYearMonthDate(organized) {
+  const day = 12 * organized.year + organized.month === isoYearMonthIndexMin ? 20 : 1;
+  return {
+    ...organized,
+    day: day
+  };
+}
+
+function finalizeDateTime(organized, resolveCalendar) {
+  return validateIsoDateTimeFields(organized), checkIsoDateTimeInBounds(organized), 
+  {
+    ...combineDateAndTime(organized, organized),
+    calendar: resolveCalendar(organized.calendarId)
+  };
+}
+
+function finalizeDate(organized, resolveCalendar) {
+  return validateIsoDateFields(organized), checkIsoDateInBounds(organized), {
+    calendar: resolveCalendar(organized.calendarId),
+    year: organized.year,
+    month: organized.month,
+    day: organized.day
+  };
+}
+
+function timeRegExpStr(separatorIndex) {
+  return `(\\d{2})(?:(:?)(\\d{2})(?:\\${separatorIndex}(\\d{2})(?:[.,](\\d{1,9}))?)?)?`;
+}
+
+function offsetRegExpStr(separatorIndex) {
+  return "([+-])" + timeRegExpStr(separatorIndex);
+}
+
+const dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))(-?)(\\d{2})\\4(\\d{2})(?:[T ]" + timeRegExpStr(8) + "(Z|" + offsetRegExpStr(15) + ")?)?";
+
+const yearMonthRegExp = /*@__PURE__*/ createRegExp("(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})");
+
+const dateTimeRegExp = /*@__PURE__*/ createRegExp(dateTimeRegExpStr + "((?:\\[(!?)([^\\]]*)\\]){0,9})");
+
+const annotationRegExp = /*@__PURE__*/ new RegExp("\\[(!?)([^\\]]*)\\]", "g");
+
+function parseDateTimeLike(s) {
+  const parts = dateTimeRegExp.exec(s);
+  return parts ? (parts => {
+    const zOrOffset = parts[12];
+    const hasZ = "Z" === (zOrOffset || "").toUpperCase();
+    return {
+      year: organizeIsoYearParts(parts),
+      month: parseInt(parts[5]),
+      day: parseInt(parts[6]),
+      ...organizeTimeParts(parts, 7),
+      ...organizeAnnotationParts(parts[19]),
+      fe: Boolean(parts[7]),
+      F: hasZ,
+      offset: hasZ ? void 0 : zOrOffset
+    };
+  })(parts) : void 0;
+}
+
+function parseYearMonthOnly(s) {
+  const parts = yearMonthRegExp.exec(s);
+  if (parts) {
+    return (parts => ({
+      year: organizeIsoYearParts(parts),
+      month: parseInt(parts[4]),
+      day: 1,
+      ...organizeAnnotationParts(parts[5])
+    }))(parts);
+  }
+}
+
+function organizeTimeParts(parts, hourIndex) {
+  const second = parseInt0(parts[hourIndex + 3]);
+  return {
+    ...nanoToTimeAndDay(parseSubsecNano(parts[hourIndex + 4] || ""))[0],
+    hour: parseInt0(parts[hourIndex]),
+    minute: parseInt0(parts[hourIndex + 2]),
+    second: 60 === second ? 59 : second
+  };
+}
+
+function organizeIsoYearParts(parts) {
+  const yearSign = parseSign(parts[1]);
+  const year = parseInt(parts[2] || parts[3]);
+  return yearSign < 0 && !year && throwRangeError(invalidSubstring(-0)), yearSign * year;
+}
+
+function organizeAnnotationParts(s) {
+  let calendarIsCritical;
+  let timeZoneId;
+  const calendarIds = [];
+  return s.replace(annotationRegExp, (whole, criticalStr, mainStr) => {
+    const isCritical = Boolean(criticalStr);
+    const [val, name] = mainStr.split("=").reverse();
+    return name ? "u-ca" === name ? (calendarIds.push(val.toLowerCase()), calendarIsCritical || (calendarIsCritical = isCritical)) : (isCritical || /[A-Z]/.test(name)) && throwRangeError(invalidSubstring(whole)) : (timeZoneId && throwRangeError(invalidSubstring(whole)), 
+    timeZoneId = val), "";
+  }), calendarIds.length > 1 && calendarIsCritical && throwRangeError(invalidSubstring(s)), 
+  {
+    timeZoneId: timeZoneId,
+    calendarId: calendarIds[0] || "iso8601"
+  };
+}
+
+function mergeCalendarFields(calendar, baseFields, additionalFields) {
+  const merged = Object.assign(Object.create(null), baseFields);
+  return spliceFields(merged, additionalFields, monthFieldNames), getCalendarEraOrigins(calendar) && (spliceFields(merged, additionalFields, allYearFieldNames), 
+  calendar && calendar.le && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
+  merged;
+}
+
+function spliceFields(dest, additional, allPropNames, deletablePropNames) {
+  let anyMatching = 0;
+  const nonMatchingPropNames = [];
+  for (const propName of allPropNames) {
+    void 0 !== additional[propName] ? anyMatching = 1 : nonMatchingPropNames.push(propName);
+  }
+  if (Object.assign(dest, additional), anyMatching) {
+    for (const deletablePropName of deletablePropNames || nonMatchingPropNames) {
+      delete dest[deletablePropName];
+    }
+  }
+}
+
+function convertPlainYearMonthToDate(calendar, input, bag) {
+  return createPlainDateFromMergedFields(calendar, pluckProps(getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), input), readAndRefineBagFields(requireObjectLike(bag), dayFieldNamesAsc, dateFieldRefiners, []));
+}
+
+function createPlainDateFromMergedFields(calendar, inputFields, extraFields) {
+  const mergedFieldNames = getCalendarFieldNames(calendar, yearMonthCodeDayFieldNamesAlpha, yearMonthCodeDayFieldNamesWithEraAlpha);
+  let mergedFields = mergeCalendarFields(calendar, inputFields, extraFields);
+  return mergedFields = readAndRefineBagFields(mergedFields, mergedFieldNames, dateFieldRefiners, []), 
+  createPlainDateFromFields(calendar, mergedFields);
+}
+
+function applyPlainFormatTimeZone(options) {
+  return options.timeZone = "UTC", [ "full", "long" ].includes(options.timeStyle) && (options.timeStyle = "medium"), 
+  options;
+}
+
+function checkResolvedCalendarCompatible(format, slots, strictCalendarCheck) {
+  const resolvedCalendarId = format.resolvedOptions().calendar;
+  slots.calendar === isoCalendarImpl || getCalendarSlotId(slots.calendar) === resolvedCalendarId || throwRangeError("Mismatching Calendars");
+}
+
+function createOptionsTransformer(shapeFieldNames, invalidShapeFieldNames, ignoredFieldNames, defaultShapeFields, dateStyleReplacementFields) {
+  const shapeFieldNameSet = new Set(shapeFieldNames);
+  const invalidShapeFieldNameSet = new Set(invalidShapeFieldNames);
+  const ignoredFieldNameSet = new Set(ignoredFieldNames);
+  return (options, allowPartialOverlap) => {
+    const analysis = ((options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet) => {
+      const analysis = {
+        dateStyle: void 0,
+        timeStyle: void 0,
+        me: {},
+        pe: {},
+        xe: {},
+        oe: 0,
+        ue: 0
+      };
+      for (const name of Object.keys(options)) {
+        const value = options[name];
+        void 0 === value || ignoredFieldNameSet.has(name) || (shapeFieldNameSet.has(name) ? "dateStyle" === name ? analysis.dateStyle = value : "timeStyle" === name ? analysis.timeStyle = value : analysis.me[name] = value : "era" === name ? analysis.pe[name] = value : invalidShapeFieldNameSet.has(name) ? "dateStyle" === name || "timeStyle" === name ? analysis.ue = 1 : analysis.oe = 1 : analysis.xe[name] = value);
+      }
+      return analysis;
+    })(options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet);
+    const hasDateStyle = void 0 !== analysis.dateStyle;
+    const hasTimeStyle = void 0 !== analysis.timeStyle;
+    const hasAnyStyle = hasDateStyle || hasTimeStyle;
+    const hasGranularShapeFields = Object.keys(analysis.me).length > 0;
+    const hasInvalids = analysis.oe || analysis.ue;
+    const hasShapeFields = hasGranularShapeFields || hasDateStyle || hasTimeStyle;
+    const hasModifierFields = Object.keys(analysis.pe).length > 0;
+    const hasStyleConflictFields = hasGranularShapeFields || hasModifierFields || analysis.oe;
+    (!allowPartialOverlap && hasInvalids || allowPartialOverlap && hasInvalids && !hasShapeFields || hasAnyStyle && hasStyleConflictFields) && throwTypeError("Invalid formatting options");
+    const transformedOptions = {};
+    return hasAnyStyle || hasShapeFields || Object.assign(transformedOptions, defaultShapeFields), 
+    Object.assign(transformedOptions, analysis.me, analysis.pe, analysis.xe), 
+    hasDateStyle && (dateStyleReplacementFields ? Object.assign(transformedOptions, dateStyleReplacementFields[analysis.dateStyle]) : transformedOptions.dateStyle = analysis.dateStyle), 
+    hasTimeStyle && (transformedOptions.timeStyle = analysis.timeStyle), transformedOptions;
+  };
+}
+
+const dateDefaultShapeFields = {
+  year: "numeric",
+  month: "numeric",
+  day: "numeric"
+};
+
+const dateShapeFieldNames = [ "weekday", "year", "month", "day", "dateStyle" ];
+
+const timeShapeFieldNames = [ "dayPeriod", "hour", "minute", "second", "fractionalSecondDigits", "timeStyle" ];
+
+const transformDateOptions = /*@__PURE__*/ createOptionsTransformer(dateShapeFieldNames, timeShapeFieldNames, [ "timeZoneName" ], dateDefaultShapeFields);
+
+function getCurrentIsoDateTime(timeZone) {
+  const epochNano = getCurrentEpochNano();
+  const offsetNano = timeZone.C(epochNano);
+  return epochNanoToIsoDateTime(epochNano + BigInt(offsetNano));
+}
+
+function getCurrentEpochNano() {
+  return BigInt(Date.now()) * bigNanoInMilli;
+}
+
+function getCurrentTimeZoneId() {
+  return (new RawDateTimeFormat).resolvedOptions().timeZone;
+}
+
+const PlainYearMonthBranding = "PlainYearMonth";
+
+const PlainDateBranding = "PlainDate";
+
+const CalendarBranding = "Calendar";
+
+function defineTemporalClass(branding, cls, getSlots, ...getterMaps) {
+  Object.defineProperties(cls, createNameDescriptors(branding)), Object.defineProperties(cls.prototype, createStringTagDescriptors("Temporal." + branding));
+  for (const getterMap of getterMaps) {
+    defineSlotGetters(cls.prototype, getSlots, getterMap);
+  }
+  return cls;
+}
+
+function defineSlotGetters(destPrototype, getSlots, getterMap) {
+  Object.defineProperties(destPrototype, mapProps(getter => ({
+    get() {
+      return getter(getSlots(this));
+    },
+    configurable: 1
+  }), getterMap));
+}
+
+const attachDebugString = "noop" === noop.name ? instance => {
+  Object.defineProperty(instance, "_str_", {
+    value: instance.toJSON()
+  });
+} : noop;
+
+function invalidRecordType() {
+  throwTypeError(invalidCallingContext);
+}
+
+function forbiddenValueOf() {
+  throwTypeError(forbiddenValueOf$1);
+}
+
+const yearMonthFieldGetters$1 = {
+  era(slots) {
+    return computeCalendarEraFields(slots.calendar, slots).era;
+  },
+  eraYear(slots) {
+    return computeCalendarEraFields(slots.calendar, slots).eraYear;
+  },
+  year(slots) {
+    return computeCalendarDateFields(slots.calendar, slots).year;
+  },
+  month(slots) {
+    return computeCalendarDateFields(slots.calendar, slots).month;
+  },
+  monthCode(slots) {
+    return computeCalendarMonthCode(slots.calendar, slots);
+  }
+};
+
+const dateFieldGetters$1 = {
+  era(slots) {
+    return computeCalendarEraFields(slots.calendar, slots).era;
+  },
+  eraYear(slots) {
+    return computeCalendarEraFields(slots.calendar, slots).eraYear;
+  },
+  year(slots) {
+    return computeCalendarDateFields(slots.calendar, slots).year;
+  },
+  month(slots) {
+    return computeCalendarDateFields(slots.calendar, slots).month;
+  },
+  monthCode(slots) {
+    return computeCalendarMonthCode(slots.calendar, slots);
+  },
+  day(slots) {
+    return computeCalendarDateFields(slots.calendar, slots).day;
+  }
+};
+
+const yearMonthDerivedGetters = {
+  daysInMonth(slots) {
+    return computeCalendarDaysInMonth(slots.calendar, slots);
+  },
+  daysInYear(slots) {
+    return computeCalendarDaysInYear(slots.calendar, slots);
+  },
+  monthsInYear(slots) {
+    return computeCalendarMonthsInYear(slots.calendar, slots);
+  },
+  inLeapYear(slots) {
+    return computeCalendarInLeapYear(slots.calendar, slots);
+  }
+};
+
+const dateDerivedGetters = {
+  dayOfWeek(slots) {
+    return computeIsoDayOfWeek(slots);
+  },
+  dayOfYear(slots) {
+    return computeCalendarDayOfYear(slots.calendar, slots);
+  },
+  weekOfYear(slots) {
+    return computeCalendarWeekOfYear(slots.calendar, slots);
+  },
+  yearOfWeek(slots) {
+    return computeCalendarYearOfWeek(slots.calendar, slots);
+  },
+  daysInWeek() {
+    return 7;
+  },
+  daysInMonth(slots) {
+    return computeCalendarDaysInMonth(slots.calendar, slots);
+  },
+  daysInYear(slots) {
+    return computeCalendarDaysInYear(slots.calendar, slots);
+  },
+  monthsInYear(slots) {
+    return computeCalendarMonthsInYear(slots.calendar, slots);
+  },
+  inLeapYear(slots) {
+    return computeCalendarInLeapYear(slots.calendar, slots);
+  }
+};
+
+function createNativeGetters(shimGetters) {
+  return createPropGetters(Object.keys(shimGetters));
+}
+
+const yearMonthFieldGetters = /*@__PURE__*/ createNativeGetters(yearMonthFieldGetters$1);
+
+const dateFieldGetters = /*@__PURE__*/ createNativeGetters(dateFieldGetters$1);
+
+createNativeGetters(yearMonthDerivedGetters), createNativeGetters(dateDerivedGetters);
+
+const PlainYearMonthRecordBranding = `${PlainYearMonthBranding}Record`;
+
+const PlainDateRecordBranding = `${PlainDateBranding}Record`;
+
+const CalendarRecordBranding = `${CalendarBranding}Record`;
+
+const calendarMap = /*@__PURE__*/ new WeakMap;
+
+const plainDateMap = /*@__PURE__*/ new WeakMap;
+
+const plainYearMonthMap = /*@__PURE__*/ new WeakMap;
+
+function getCalendarSlots(record) {
+  return getCalendarSlotsIfPresent(record) || invalidRecordType();
+}
+
+function getCalendarSlotsIfPresent(record) {
+  return calendarMap.get(record);
+}
+
+function getPlainDateSlots(record) {
+  return getPlainDateSlotsIfPresent(record) || invalidRecordType();
+}
+
+function getPlainDateSlotsIfPresent(record) {
+  return plainDateMap.get(record);
+}
+
+function setPlainDateSlots(instance, slots) {
+  plainDateMap.set(instance, slots);
+}
+
+function isPlainYearMonthRecord(record) {
+  return !!getPlainYearMonthSlotsIfPresent(record);
+}
+
+function getPlainYearMonthSlots(record) {
+  return getPlainYearMonthSlotsIfPresent(record) || invalidRecordType();
+}
+
+function getPlainYearMonthSlotsIfPresent(record) {
+  return plainYearMonthMap.get(record);
+}
+
+function setPlainYearMonthSlots(instance, slots) {
+  plainYearMonthMap.set(instance, slots);
+}
+
+const CalendarRecord = /*@__PURE__*/ defineTemporalClass(CalendarRecordBranding, class {
+  toJSON() {
+    return getCalendarRecordId(this);
+  }
+  valueOf() {
+    return getCalendarRecordId(this);
+  }
+});
+
+function createCalendarRecord(id, getImpl) {
+  const instance = Object.create(CalendarRecord.prototype);
+  return ((instance, slots) => {
+    calendarMap.set(instance, slots);
+  })(instance, {
+    id: id,
+    Be: getImpl
+  }), attachDebugString(instance), instance;
+}
+
+function getCalendarRecordId(record) {
+  return getCalendarSlots(record).id;
+}
+
+function getCalendarRecordImplCreator(record) {
+  const getImpl = getCalendarSlots(record).Be;
+  return getImpl || throwRangeError(exoticCalendarRequired(getCalendarRecordId(record), "getExotic or getAny")), 
+  getImpl;
+}
+
+const isoCalendarRecord = /*@__PURE__*/ createCalendarRecord(isoCalendarId, () => isoCalendarImpl);
+
+const gregoryCalendarRecord = /*@__PURE__*/ createCalendarRecord(gregoryCalendarId, () => gregoryCalendarImpl);
+
+function getBasic(rawCalendarId) {
+  const lowerRawCalendarId = requireString(rawCalendarId).toLowerCase();
+  return lowerRawCalendarId === isoCalendarId ? isoCalendarRecord : lowerRawCalendarId === gregoryCalendarId ? gregoryCalendarRecord : getOrCreateUnknownRecord(rawCalendarId);
+}
+
+const getOrCreateUnknownRecord = /*@__PURE__*/ memoize(createCalendarRecord);
+
+const NativeTemporal = globalThis.Temporal;
+
+function refineNativeCalendarArgMaybe(calendarRecord) {
+  if (void 0 !== calendarRecord) {
+    return getValidatedCalendarId(calendarRecord);
+  }
+}
+
+function runNativeCalendarResolver(canonicalCalendarId, getCalendarRecord) {
+  getValidatedCalendarId(getCalendarRecord(canonicalCalendarId));
+}
+
+function getValidatedCalendarId(record) {
+  return getCalendarRecordImplCreator(record), getCalendarRecordId(record);
+}
+
+const getNativePlainYearMonth = getPlainYearMonthSlots;
+
+const NativePlainYearMonthRecord = /*@__PURE__*/ defineTemporalClass(PlainYearMonthRecordBranding, class {
+  get calendarId() {
+    return getNativePlainYearMonth(this).calendarId;
+  }
+  toJSON() {
+    return getNativePlainYearMonth(this).toJSON();
+  }
+  valueOf() {
+    return getNativePlainYearMonth(this).valueOf();
+  }
+}, getNativePlainYearMonth, yearMonthFieldGetters);
+
+function createNativePlainYearMonthRecord(native) {
+  const instance = Object.create(NativePlainYearMonthRecord.prototype);
+  return setPlainYearMonthSlots(instance, native), attachDebugString(instance), instance;
+}
+
+function fromString$3$1(s, getCalendarRecord) {
+  const resNative = NativeTemporal.PlainYearMonth.from(s);
+  return runNativeCalendarResolver(resNative.calendarId, getCalendarRecord), createNativePlainYearMonthRecord(resNative);
+}
+
+function daysInMonth$2$1(record) {
+  return getNativePlainYearMonth(record).daysInMonth;
+}
+
+function compare$3$1(record, otherRecord) {
+  const native = getNativePlainYearMonth(record);
+  const otherNative = getNativePlainYearMonth(otherRecord);
+  return NativeTemporal.PlainYearMonth.compare(native, otherNative);
+}
+
+function toString$3$1(record, options) {
+  return getNativePlainYearMonth(record).toString(options);
+}
+
+function toPlainDate$1$1(record, fields) {
+  return createNativePlainDateRecord(getNativePlainYearMonth(record).toPlainDate(fields));
+}
+
+function addMonths$2$1(record, months, options) {
+  return createNativePlainYearMonthRecord(getNativePlainYearMonth(record).add({
+    months: months
+  }, options));
+}
+
+const getNativePlainDate = getPlainDateSlots;
+
+const NativePlainDateRecord = /*@__PURE__*/ defineTemporalClass(PlainDateRecordBranding, class {
+  get calendarId() {
+    return getNativePlainDate(this).calendarId;
+  }
+  toJSON() {
+    return getNativePlainDate(this).toJSON();
+  }
+  valueOf() {
+    return getNativePlainDate(this).valueOf();
+  }
+}, getNativePlainDate, dateFieldGetters);
+
+function createNativePlainDateRecord(native) {
+  const instance = Object.create(NativePlainDateRecord.prototype);
+  return setPlainDateSlots(instance, native), attachDebugString(instance), instance;
+}
+
+function fromFields$1$1(fields, options) {
+  const calendar = refineNativeCalendarArgMaybe(fields.calendar);
+  return createNativePlainDateRecord(NativeTemporal.PlainDate.from({
+    ...fields,
+    calendar: calendar
+  }, options));
+}
+
+function fromString$2$1(s, getCalendarRecord) {
+  const resNative = NativeTemporal.PlainDate.from(s);
+  return runNativeCalendarResolver(resNative.calendarId, getCalendarRecord), createNativePlainDateRecord(resNative);
+}
+
+function dayOfWeek$1$1(record) {
+  return getNativePlainDate(record).dayOfWeek;
+}
+
+function compare$2$1(record, otherRecord) {
+  const native = getNativePlainDate(record);
+  const otherNative = getNativePlainDate(otherRecord);
+  return NativeTemporal.PlainDate.compare(native, otherNative);
+}
+
+function toLocaleString$2$1(record, locales, options) {
+  return getNativePlainDate(record).toLocaleString(locales, options);
+}
+
+function toString$2$1(record, options) {
+  return getNativePlainDate(record).toString(options);
+}
+
+function toPlainYearMonth$2(record) {
+  return createNativePlainYearMonthRecord(getNativePlainDate(record).toPlainYearMonth());
+}
+
+function addYears$1$1(record, years, options) {
+  return createNativePlainDateRecord(getNativePlainDate(record).add({
+    years: years
+  }, options));
+}
+
+function addMonths$1$2(record, months, options) {
+  return createNativePlainDateRecord(getNativePlainDate(record).add({
+    months: months
+  }, options));
+}
+
+function addDays$1$1(record, days) {
+  return createNativePlainDateRecord(getNativePlainDate(record).add({
+    days: days
+  }));
+}
+
+function plainDateISO$2(timeZoneId) {
+  return createNativePlainDateRecord(NativeTemporal.Now.plainDateISO(timeZoneId));
+}
+
+function refineShimCalendarArgMaybe(calendarRecord) {
+  return void 0 === calendarRecord ? isoCalendarImpl : getCalendarRecordImpl(calendarRecord);
+}
+
+function createShimCalendarStringResolver(getCalendarRecord) {
+  return calendarId => getCalendarRecordImpl(getCalendarRecord(calendarId.toLowerCase()));
+}
+
+function getCalendarRecordImpl(record) {
+  return getCalendarRecordImplCreator(record)();
+}
+
+function moveByYears(calendar, isoDate, years, options) {
+  const overflow = refineOverflowOptions(options);
+  return years ? addDateMonths(calendar, isoDate, toStrictInteger(years), 0, overflow) : isoDate;
+}
+
+function moveByMonths(calendar, isoDate, months, options) {
+  const overflow = refineOverflowOptions(options);
+  return months ? addDateMonths(calendar, isoDate, 0, toStrictInteger(months), overflow) : isoDate;
+}
+
+function moveByDaysStrict(_calendar, isoDate, days) {
+  return moveByDays(isoDate, toStrictInteger(days));
+}
+
+const getShimPlainYearMonthSlots = getPlainYearMonthSlots;
+
+const ShimPlainYearMonthRecord = /*@__PURE__*/ defineTemporalClass(PlainYearMonthRecordBranding, class {
+  get calendarId() {
+    return getCalendarSlotId(getShimPlainYearMonthSlots(this).calendar);
+  }
+  toJSON() {
+    return formatYearMonthIsoAuto(getShimPlainYearMonthSlots(this));
+  }
+  valueOf() {
+    return forbiddenValueOf();
+  }
+}, getShimPlainYearMonthSlots, yearMonthFieldGetters$1);
+
+function createShimPlainYearMonthRecord(slots) {
+  const instance = Object.create(ShimPlainYearMonthRecord.prototype);
+  return setPlainYearMonthSlots(instance, slots), attachDebugString(instance), instance;
+}
+
+function fromString$3(s, getCalendarRecord) {
+  return createShimPlainYearMonthRecord(parsePlainYearMonth(s, createShimCalendarStringResolver(getCalendarRecord)));
+}
+
+function daysInMonth$2(record) {
+  const slots = getShimPlainYearMonthSlots(record);
+  return computeCalendarDaysInMonth(slots.calendar, slots);
+}
+
+function compare$3(record, otherRecord) {
+  const slots = getShimPlainYearMonthSlots(record);
+  const otherSlots = getShimPlainYearMonthSlots(otherRecord);
+  return compareIsoDateFields(slots, otherSlots);
+}
+
+function toString$3(record, options) {
+  return formatPlainYearMonthIso(getShimPlainYearMonthSlots(record), options);
+}
+
+function toPlainDate$1(record, fields) {
+  const slots = getShimPlainYearMonthSlots(record);
+  return createShimPlainDateRecord(convertPlainYearMonthToDate(slots.calendar, record, fields));
+}
+
+function addMonths$2(record, months, options) {
+  const slots = getShimPlainYearMonthSlots(record);
+  return createShimPlainYearMonthRecord(createDateSlots(moveYearMonth(0, slots.calendar, slots, createDurationSlots(validateDurationFields({
+    ...durationFieldDefaults,
+    months: toStrictInteger(months)
+  })), options), slots.calendar));
+}
+
+const getShimPlainDateSlots = getPlainDateSlots;
+
+const ShimPlainDateRecord = /*@__PURE__*/ defineTemporalClass(PlainDateRecordBranding, class {
+  get calendarId() {
+    return getCalendarSlotId(getShimPlainDateSlots(this).calendar);
+  }
+  toJSON() {
+    return formatDateIsoAuto(getShimPlainDateSlots(this));
+  }
+  valueOf() {
+    return forbiddenValueOf();
+  }
+}, getShimPlainDateSlots, dateFieldGetters$1);
+
+function createShimPlainDateRecord(slots) {
+  const instance = Object.create(ShimPlainDateRecord.prototype);
+  return setPlainDateSlots(instance, slots), attachDebugString(instance), instance;
+}
+
+function fromFields$1(fields, options) {
+  const calendarImpl = refineShimCalendarArgMaybe(fields.calendar);
+  return createShimPlainDateRecord(refinePlainDateObjectLike(calendarImpl, fields, options));
+}
+
+function fromString$2(s, getCalendarRecord) {
+  return createShimPlainDateRecord(parsePlainDate(s, createShimCalendarStringResolver(getCalendarRecord)));
+}
+
+function dayOfWeek$1(record) {
+  return computeIsoDayOfWeek(getShimPlainDateSlots(record));
+}
+
+function compare$2(record, otherRecord) {
+  const slots = getShimPlainDateSlots(record);
+  const otherSlots = getShimPlainDateSlots(otherRecord);
+  return compareIsoDateFields(slots, otherSlots);
+}
+
+function toLocaleString$2(record, locales = void 0, options = {}) {
+  const slots = getShimPlainDateSlots(record);
+  const format = new RawDateTimeFormat(locales, applyPlainFormatTimeZone(transformDateOptions(options)));
+  return checkResolvedCalendarCompatible(format, slots), format.format(isoDateToEpochMilli(slots));
+}
+
+function toString$2(record, options) {
+  return formatPlainDateIso(getShimPlainDateSlots(record), options);
+}
+
+function toPlainYearMonth$1(record) {
+  const slots = getShimPlainDateSlots(record);
+  const calendarDate = computeCalendarDateFields(slots.calendar, slots);
+  return createShimPlainYearMonthRecord(createPlainYearMonthFromFields(slots.calendar, {
+    year: calendarDate.year,
+    monthCode: computeCalendarMonthCode(slots.calendar, slots)
+  }));
+}
+
+function addYears$1(record, years, options) {
+  const slots = getShimPlainDateSlots(record);
+  return createRecordFromDateFields(createDateSlots(moveByYears(slots.calendar, slots, years, options), slots.calendar));
+}
+
+function addMonths$1$1(record, months, options) {
+  const slots = getShimPlainDateSlots(record);
+  return createRecordFromDateFields(createDateSlots(moveByMonths(slots.calendar, slots, months, options), slots.calendar));
+}
+
+function addDays$1(record, days) {
+  const slots = getShimPlainDateSlots(record);
+  return createRecordFromDateFields(createDateSlots(moveByDaysStrict(slots.calendar, slots, days), slots.calendar));
+}
+
+function createRecordFromDateFields(isoDate) {
+  return checkIsoDateInBounds(isoDate), createShimPlainDateRecord(createDateSlots(isoDate, isoDate.calendar));
+}
+
+function plainDateISO$1(timeZoneId = getCurrentTimeZoneId()) {
+  const isoDateTime = getCurrentIsoDateTime(queryTimeZone(refineTimeZoneId(timeZoneId)));
+  return createShimPlainDateRecord(createDateSlots(isoDateTime));
+}
+
+const plainDateISO = NativeTemporal ? plainDateISO$2 : plainDateISO$1;
+
+const fromFields = NativeTemporal ? fromFields$1$1 : fromFields$1;
+
+const fromString$1 = NativeTemporal ? fromString$2$1 : fromString$2;
+
+const dayOfWeek = NativeTemporal ? dayOfWeek$1$1 : dayOfWeek$1;
+
+const compare$1 = NativeTemporal ? compare$2$1 : compare$2;
+
+const toLocaleString = NativeTemporal ? toLocaleString$2$1 : toLocaleString$2;
+
+const toString$1 = NativeTemporal ? toString$2$1 : toString$2;
+
+const toPlainYearMonth = NativeTemporal ? toPlainYearMonth$2 : toPlainYearMonth$1;
+
+const addYears = NativeTemporal ? addYears$1$1 : addYears$1;
+
+const addMonths$1 = NativeTemporal ? addMonths$1$2 : addMonths$1$1;
+
+const addDays = NativeTemporal ? addDays$1$1 : addDays$1;
+
+const isRecord = isPlainYearMonthRecord;
+
+const fromString = NativeTemporal ? fromString$3$1 : fromString$3;
+
+const daysInMonth = NativeTemporal ? daysInMonth$2$1 : daysInMonth$2;
+
+const compare = NativeTemporal ? compare$3$1 : compare$3;
+
+const toString = NativeTemporal ? toString$3$1 : toString$3;
+
+const toPlainDate = NativeTemporal ? toPlainDate$1$1 : toPlainDate$1;
+
+const addMonths = NativeTemporal ? addMonths$2$1 : addMonths$2;
+
+const chevronLeftSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTE1LjMzMzQgMjAuMzMzNEw3LjAwMDA4IDEyTDE1LjMzMzQgMy42NjY2MyIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS13aWR0aD0iMS43NSIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+Cjwvc3ZnPgo=';
+
+const chevronRightSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTguNjY2NjMgMjAuMzMzNEwxNyAxMkw4LjY2NjYzIDMuNjY2NjMiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2Utd2lkdGg9IjEuNzUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgo8L3N2Zz4K';
+
+function parseIsoDateSafely(iso, format = fromString$1) {
+    if (!iso)
+        return undefined;
+    try {
+        return format(iso, getBasic);
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripDayFromIsoDate(iso) {
+    return iso.slice(0, 7);
+}
+/**
+ * Serialize a PlainDate to an ISO YYYY-MM-DD string.
+ *
+ * IMPORTANT: the `fns` flavor of `temporal-polyfill` records do NOT carry a working instance
+ * `.toString()` (calling it falls through to `Object.prototype.toString`, yielding
+ * `"[object Temporal.PlainDateRecord]"`). Always use the top-level `PlainDateFns.toString()`.
+ */
+function toIsoDateString(date) {
+    return toString$1(date);
+}
+function toIsoYearMonthString(date) {
+    if (isRecord(date)) {
+        return toString(date);
+    }
+    return stripDayFromIsoDate(toIsoDateString(date));
+}
+
+const calendarSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIKICAgIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CiAgICA8cmVjdCB4PSIzLjUiIHk9IjUiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNSIgcng9IjIiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2Utd2lkdGg9IjEuNzUiLz4KICAgIDxwYXRoIGQ9Ik0zLjUgOS41SDIwLjUiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2Utd2lkdGg9IjEuNzUiLz4KICAgIDxwYXRoIGQ9Ik04IDNWNi41IiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIxLjc1IiBzdHJva2UtbGluZWNhcD0icm91bmQiLz4KICAgIDxwYXRoIGQ9Ik0xNiAzVjYuNSIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS13aWR0aD0iMS43NSIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIi8+Cjwvc3ZnPg==';
+
+function isSelected(date, value) {
+    if (!value)
+        return false;
+    return compare$1(date, value) === 0;
+}
+function isDisabled(date, min, max) {
+    if (min && compare$1(date, min) < 0)
+        return true;
+    if (max && compare$1(date, max) > 0)
+        return true;
+    return false;
+}
+function buildCalendarGrid(visibleMonth) {
+    const firstOfMonth = toPlainDate(visibleMonth, { day: 1 });
+    const firstDow = dayOfWeek(firstOfMonth);
+    const offsetToMonday = firstDow - 1;
+    const gridStart = addDays(firstOfMonth, -offsetToMonday);
+    const grid = [];
+    for (let i = 0; i < 42; i++) {
+        grid.push(addDays(gridStart, i));
+    }
+    if (compare(visibleMonth, toPlainYearMonth(grid.at(-7))) !== 0) {
+        return grid.slice(0, -7);
+    }
+    return grid;
+}
+function firstSelectableDayOfMonth(visibleMonth, min, max) {
+    const daysInMonth$1 = daysInMonth(visibleMonth);
+    for (let d = 1; d <= daysInMonth$1; d++) {
+        const candidate = toPlainDate(visibleMonth, { day: d });
+        if (!isDisabled(candidate, min, max))
+            return candidate;
+    }
+    return null;
+}
+function lastSelectableDayOfMonth(visibleMonth, min, max) {
+    const daysInMonth$1 = daysInMonth(visibleMonth);
+    for (let d = daysInMonth$1; d >= 1; d--) {
+        const candidate = toPlainDate(visibleMonth, { day: d });
+        if (!isDisabled(candidate, min, max))
+            return candidate;
+    }
+    return null;
+}
+const NAV_LABELS = {
+    de: { prev: 'Vorheriger Monat', next: 'Nächster Monat' },
+    'de-CH': { prev: 'Vorheriger Monat', next: 'Nächster Monat' },
+    'de-AT': { prev: 'Vorheriger Monat', next: 'Nächster Monat' },
+    'de-DE': { prev: 'Vorheriger Monat', next: 'Nächster Monat' },
+    en: { prev: 'Previous month', next: 'Next month' },
+    'en-US': { prev: 'Previous month', next: 'Next month' },
+    'en-GB': { prev: 'Previous month', next: 'Next month' },
+    fr: { prev: 'Mois précédent', next: 'Mois suivant' },
+    'fr-CH': { prev: 'Mois précédent', next: 'Mois suivant' },
+    it: { prev: 'Mese precedente', next: 'Mese successivo' },
+    'it-CH': { prev: 'Mese precedente', next: 'Mese successivo' },
+};
+function getNavLabels(locale) {
+    const DEFAULT = { prev: 'Vorheriger Monat', next: 'Nächster Monat' };
+    const byLocale = NAV_LABELS[locale];
+    if (byLocale)
+        return byLocale;
+    const lang = locale.split('-')[0];
+    const byLang = lang !== undefined ? NAV_LABELS[lang] : undefined;
+    if (byLang)
+        return byLang;
+    return DEFAULT;
+}
+const VALIDATION_LABELS = {
+    de: { popoverSuffix: '— Kalender', invalidDateMessage: 'Ungültiges Datum' },
+    'de-CH': { popoverSuffix: '— Kalender', invalidDateMessage: 'Ungültiges Datum' },
+    'de-AT': { popoverSuffix: '— Kalender', invalidDateMessage: 'Ungültiges Datum' },
+    'de-DE': { popoverSuffix: '— Kalender', invalidDateMessage: 'Ungültiges Datum' },
+    en: { popoverSuffix: '— Calendar', invalidDateMessage: 'Invalid date' },
+    'en-US': { popoverSuffix: '— Calendar', invalidDateMessage: 'Invalid date' },
+    'en-GB': { popoverSuffix: '— Calendar', invalidDateMessage: 'Invalid date' },
+    fr: { popoverSuffix: '— Calendrier', invalidDateMessage: 'Date invalide' },
+    'fr-CH': { popoverSuffix: '— Calendrier', invalidDateMessage: 'Date invalide' },
+    it: { popoverSuffix: '— Calendario', invalidDateMessage: 'Data non valida' },
+    'it-CH': { popoverSuffix: '— Calendario', invalidDateMessage: 'Data non valida' },
+};
+function getValidationLabels(locale) {
+    const DEFAULT = { popoverSuffix: '— Kalender', invalidDateMessage: 'Ungültiges Datum' };
+    const byLocale = VALIDATION_LABELS[locale];
+    if (byLocale)
+        return byLocale;
+    const lang = locale.split('-')[0];
+    const byLang = lang !== undefined ? VALIDATION_LABELS[lang] : undefined;
+    if (byLang)
+        return byLang;
+    return DEFAULT;
+}
+const FORMAT_TOKEN_ORDER = ['yyyy', 'MM', 'dd'];
+function derivePatternFromLocale(locale) {
+    const reference = new Date(Date.UTC(2001, 10, 22));
+    const parts = new Intl.DateTimeFormat(locale, { year: 'numeric', month: '2-digit', day: '2-digit', timeZone: 'UTC' }).formatToParts(reference);
+    return parts
+        .map((part) => {
+        switch (part.type) {
+            case 'year':
+                return 'yyyy';
+            case 'month':
+                return 'MM';
+            case 'day':
+                return 'dd';
+            default:
+                return part.value;
+        }
+    })
+        .join('');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildPatternMatcher(pattern) {
+    const order = [];
+    let regexSource = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const token = FORMAT_TOKEN_ORDER.find((t) => pattern.startsWith(t, i));
+        if (token) {
+            regexSource += token === 'yyyy' ? '(\\d{4})' : '(\\d{1,2})';
+            order.push(token);
+            i += token.length;
+        }
+        else {
+            regexSource += escapeRegExp(pattern[i]);
+            i += 1;
+        }
+    }
+    return { regex: new RegExp(`^${regexSource}$`), order };
+}
+function isValidCalendarDate(year, month, day) {
+    if (!Number.isInteger(year) || year < 1)
+        return false;
+    if (!Number.isInteger(month) || month < 1 || month > 12)
+        return false;
+    if (!Number.isInteger(day) || day < 1)
+        return false;
+    try {
+        const ym = fromString(`${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}`, getBasic);
+        return day <= daysInMonth(ym);
+    }
+    catch {
+        return false;
+    }
+}
+function formatToDisplay(value, locale, displayFormat) {
+    if (!value)
+        return '';
+    const date = parseIsoDateSafely(value);
+    if (!date)
+        return '';
+    const pattern = displayFormat ?? derivePatternFromLocale(locale);
+    const yyyy = String(date.year).padStart(4, '0');
+    const MM = String(date.month).padStart(2, '0');
+    const dd = String(date.day).padStart(2, '0');
+    return pattern.replace(/yyyy/g, yyyy).replace(/MM/g, MM).replace(/dd/g, dd);
+}
+function parseFromDisplay(text, locale, displayFormat) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    const pattern = displayFormat ?? derivePatternFromLocale(locale);
+    const { regex, order } = buildPatternMatcher(pattern);
+    const match = regex.exec(trimmed);
+    if (!match)
+        return undefined;
+    const values = {};
+    order.forEach((token, idx) => {
+        values[token] = Number(match[idx + 1]);
+    });
+    const { yyyy, MM, dd } = values;
+    if (yyyy === undefined || MM === undefined || dd === undefined)
+        return undefined;
+    if (!isValidCalendarDate(yyyy, MM, dd))
+        return undefined;
+    return `${String(yyyy).padStart(4, '0')}-${String(MM).padStart(2, '0')}-${String(dd).padStart(2, '0')}`;
+}
+
+const lmvzDatepickerCss = () => ` @layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } :host {   display: inline-block;   width: 100%; }  .datepicker-panel {   display: flex;   flex-direction: column;   gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)); } .datepicker-header {   display: flex;   align-items: center;   justify-content: space-between;   width: 100%; } .datepicker-month-label {      all: unset;      font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   color: var(--lmvz-semantic-color-on-surface-primary, #000000);   text-align: center;   cursor: default;      pointer-events: none;   user-select: none; } .datepicker-weekday-row {   display: flex;   gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   width: 100%; } .datepicker-weekday {   flex: 1;   display: flex;   align-items: center;   justify-content: center;   font: var(--lmvz-typography-body-sm-strong, 500 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5     Router);   color: var(--lmvz-semantic-color-on-surface-secondary, #545454);   min-width: 0;   text-align: center; } .datepicker-grid {   display: flex;   flex-direction: column;   gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); } .datepicker-week-row {   display: flex;   gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); } [part~='day'] {      all: unset;      flex: 1;      width: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   min-width: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   box-sizing: border-box;    display: flex;   align-items: center;   justify-content: center;    border-radius: var(--lmvz-semantic-border-radius-round, 999px);   font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   color: var(--lmvz-semantic-color-on-surface-primary, #000000);   background-color: transparent;   cursor: pointer;      transition:     background-color 0.15s ease,     color 0.15s ease;      position: relative; } [part~='day--disabled'], [part~='day']:disabled {   opacity: var(--lmvz-global-opacity-disabled, 40%);   pointer-events: none; } [part~='day']:focus-visible {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); } [part~='day']:not(:disabled):hover {   background-color: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   color: var(--lmvz-semantic-color-on-surface-primary, #000000); } [part~='day--today'] {   box-shadow: inset 0 0 0 1px var(--lmvz-semantic-color-border-active, #0f8acc); } [part~='day--today']:not(:disabled):hover {   background-color: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   box-shadow: inset 0 0 0 1px var(--lmvz-semantic-color-border-active, #0f8acc); } [part~='day--selected'] {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff);   box-shadow: none; } [part~='day--today'][part~='day--selected'] {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff);   box-shadow: none; } [part~='day--selected']:not(:disabled):hover {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } [part~='day--out-of-month'] {   color: var(--lmvz-semantic-color-on-surface-tertiary, #7a7a7a); } `;
+
+const CHEVRON_LEFT = toValidSvgStringWithFallback(chevronLeftSvg);
+const CHEVRON_RIGHT = toValidSvgStringWithFallback(chevronRightSvg);
+const CALENDAR_ICON = toValidSvgStringWithFallback(calendarSvg);
+class LmvzDatepicker {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.lmvzChange = createEvent(this, "lmvzChange", 7);
+        this.lmvzMonthChange = createEvent(this, "lmvzMonthChange", 7);
+        this.lmvzOpen = createEvent(this, "lmvzOpen", 7);
+        this.lmvzClose = createEvent(this, "lmvzClose", 7);
+        if (hostRef.$hostElement$["s-ei"]) {
+            this.internals = hostRef.$hostElement$["s-ei"];
+        }
+        else {
+            this.internals = hostRef.$hostElement$.attachInternals();
+            hostRef.$hostElement$["s-ei"] = this.internals;
+        }
+    }
+    get el() { return getElement(this); }
+    monthLabelId = `lmvz-dp-month-${Math.random().toString(36).slice(2, 9)}`;
+    internals;
+    visibleDays;
+    inputEl;
+    focusedButtonRef;
+    initialValue;
+    pendingGridFocus = false;
+    syncOrigin = null;
+    focusedDate;
+    setFocusedDate(val) {
+        if (this.focusedDate === val || (this.focusedDate && val && compare$1(this.focusedDate, val) === 0))
+            return;
+        this.focusedDate = val;
+    }
+    valueDate;
+    get value() {
+        return this.valueDate ? toIsoDateString(this.valueDate) : undefined;
+    }
+    set value(value) {
+        this.valueDate = value ? parseIsoDateSafely(value) : undefined;
+        this.visibleMonthDate = this.valueDate ? toPlainYearMonth(this.valueDate) : this.effectiveVisibleMonth;
+        this.setFocusedDate(this.valueDate);
+        this.syncInputTextFromValue();
+        this.updateFormState();
+    }
+    visibleMonthDate;
+    get visibleMonth() {
+        return this.visibleMonthDate ? toIsoYearMonthString(this.visibleMonthDate) : undefined;
+    }
+    set visibleMonth(value) {
+        this.visibleMonthDate = value ? fromString(value, getBasic) : undefined;
+        this.initFocusedDate();
+    }
+    min;
+    max;
+    locale = 'de-CH';
+    firstDayOfWeek = 1;
+    disabled = false;
+    readonly = false;
+    required = false;
+    name;
+    label;
+    placeholder;
+    helperText;
+    errorMessage;
+    open = false;
+    displayFormat;
+    lmvzChange;
+    lmvzMonthChange;
+    lmvzOpen;
+    lmvzClose;
+    componentWillLoad() {
+        if (!this.label) {
+            console.warn('[lmvz-datepicker] no `label` provided; the text field will have no accessible name.');
+        }
+        this.initialValue = this.value;
+        this.syncInputTextFromValue();
+        this.updateFormState();
+    }
+    formAssociatedCallback(form) {
+        if (!form)
+            return;
+        this.updateFormState();
+    }
+    formResetCallback() {
+        this.internals.setValidity?.({});
+        this.value = this.initialValue;
+    }
+    formStateRestoreCallback(state) {
+        if (typeof state !== 'string')
+            return;
+        this.value = (state || undefined);
+    }
+    async checkValidity() {
+        return this.internals.checkValidity?.() ?? true;
+    }
+    async reportValidity() {
+        return this.internals.reportValidity?.() ?? true;
+    }
+    handleValidityRelevantPropChange() {
+        this.updateFormState();
+    }
+    handleDisplayFormatChange() {
+        this.syncInputTextFromValue();
+    }
+    handleDisabledChange(disabled) {
+        if (disabled)
+            this.open = false;
+    }
+    handleKeydown(ev) {
+        if (this.disabled)
+            return;
+        const path = ev.composedPath();
+        if (!path.some((el) => el?.getAttribute?.('role') === 'grid'))
+            return;
+        const focused = this.focusedDate;
+        if (!focused) {
+            console.warn('[lmvz-datepicker] any date should be focused but none is.');
+            return;
+        }
+        const minDate = parseIsoDateSafely(this.min);
+        const maxDate = parseIsoDateSafely(this.max);
+        const swallowEvent = () => {
+            ev.preventDefault();
+            ev.stopPropagation();
+        };
+        switch (ev.key) {
+            case 'ArrowRight': {
+                swallowEvent();
+                this.moveFocus(addDays(focused, 1));
+                break;
+            }
+            case 'ArrowLeft': {
+                swallowEvent();
+                this.moveFocus(addDays(focused, -1));
+                break;
+            }
+            case 'ArrowDown': {
+                swallowEvent();
+                this.moveFocus(addDays(focused, 7));
+                break;
+            }
+            case 'ArrowUp': {
+                swallowEvent();
+                this.moveFocus(addDays(focused, -7));
+                break;
+            }
+            case 'Home': {
+                swallowEvent();
+                this.moveFocus(firstSelectableDayOfMonth(this.effectiveVisibleMonth, minDate, maxDate));
+                break;
+            }
+            case 'End': {
+                swallowEvent();
+                this.moveFocus(lastSelectableDayOfMonth(this.effectiveVisibleMonth, minDate, maxDate));
+                break;
+            }
+            case 'PageUp':
+                swallowEvent();
+                this.moveFocus(ev.shiftKey ? addYears(focused, -1) : addMonths$1(focused, -1));
+                break;
+            case 'PageDown':
+                swallowEvent();
+                this.moveFocus(ev.shiftKey ? addYears(focused, 1) : addMonths$1(focused, 1));
+                break;
+            case 'Enter':
+            case ' ':
+                ev.preventDefault();
+                if (!this.readonly && !isDisabled(focused, minDate, maxDate)) {
+                    this.selectDate(focused, { origin: 'calendar', closePopover: true });
+                }
+                break;
+        }
+    }
+    initFocusedDate() {
+        const vm = this.effectiveVisibleMonth;
+        if (this.focusedDate && compare(toPlainYearMonth(this.focusedDate), vm) === 0) {
+            return;
+        }
+        const selectedDate = this.valueDate;
+        if (selectedDate && compare(toPlainYearMonth(selectedDate), vm) === 0) {
+            this.setFocusedDate(selectedDate);
+            return;
+        }
+        const todayDate = plainDateISO();
+        if (compare(toPlainYearMonth(todayDate), vm) === 0) {
+            this.setFocusedDate(todayDate);
+            return;
+        }
+        this.setFocusedDate(toPlainDate(vm, { day: 1 }));
+    }
+    get effectiveVisibleMonth() {
+        return this.visibleMonthDate ? this.visibleMonthDate : toPlainYearMonth(plainDateISO());
+    }
+    navigateMonth(delta, byMonthNav = false) {
+        if (delta === 0)
+            return;
+        const newMonth = addMonths(this.effectiveVisibleMonth, delta);
+        this.visibleMonthDate = newMonth;
+        this.lmvzMonthChange.emit({ visibleMonth: toIsoYearMonthString(newMonth) });
+        if (byMonthNav) {
+            this.setFocusedDate(toPlainDate(newMonth, { day: 1 }));
+        }
+    }
+    selectDate(date, opts = { origin: 'calendar' }) {
+        this.syncOrigin = opts.origin;
+        this.valueDate = date;
+        this.setFocusedDate(date);
+        this.lmvzChange.emit({ value: toIsoDateString(date) });
+        this.navigateMonth(compare(toPlainYearMonth(date), this.effectiveVisibleMonth));
+        if (opts.origin === 'input') {
+            this.inputText = formatToDisplay(this.value, this.locale, this.displayFormat);
+            this.hasUnparseableInput = false;
+        }
+        else {
+            this.syncInputTextFromValue();
+        }
+        this.updateFormState();
+        if (opts.closePopover)
+            this.open = false;
+        this.syncOrigin = null;
+    }
+    moveFocus(date) {
+        if (!date)
+            return;
+        this.setFocusedDate(date);
+        if (!this.visibleDays?.length)
+            return;
+        let day = this.visibleDays.at(0);
+        if (day && compare$1(date, day) < 0) {
+            return this.navigateMonth(-1);
+        }
+        day = this.visibleDays.at(-1);
+        if (day && compare$1(date, day) > 0) {
+            return this.navigateMonth(1);
+        }
+    }
+    syncInputTextFromValue() {
+        if (this.syncOrigin === 'input')
+            return;
+        this.inputText = formatToDisplay(this.value, this.locale, this.displayFormat);
+        this.hasUnparseableInput = false;
+    }
+    inputText = '';
+    hasUnparseableInput = false;
+    handleInputTextChange = (ev) => {
+        const text = ev.detail;
+        this.inputText = text;
+        if (!text.trim()) {
+            this.hasUnparseableInput = false;
+            if (this.valueDate) {
+                this.syncOrigin = 'input';
+                this.valueDate = undefined;
+                this.lmvzChange.emit({ value: undefined });
+                this.syncOrigin = null;
+            }
+            this.updateFormState();
+            return;
+        }
+        const parsed = parseFromDisplay(text, this.locale, this.displayFormat);
+        if (!parsed) {
+            this.hasUnparseableInput = true;
+            this.updateFormState();
+            return;
+        }
+        this.hasUnparseableInput = false;
+        const parsedDate = parseIsoDateSafely(parsed);
+        if (!parsedDate)
+            return;
+        if (this.valueDate && compare$1(this.valueDate, parsedDate) === 0)
+            return;
+        this.selectDate(parsedDate, { origin: 'input' });
+    };
+    handleInputFocus(ev) {
+        if (this.disabled || this.readonly)
+            return;
+        const originalTarget = ev.composedPath()[0];
+        if (originalTarget !== this.inputEl && !this.inputEl?.contains(originalTarget ?? null))
+            return;
+        this.initFocusedDate();
+        this.open = true;
+    }
+    handleInputKeydown = (ev) => {
+        if (this.disabled || this.readonly)
+            return;
+        if (!['ArrowDown', 'ArrowUp', ' '].includes(ev.key))
+            return;
+        ev.preventDefault();
+        if (!this.open) {
+            this.pendingGridFocus = true;
+            this.initFocusedDate();
+            this.open = true;
+        }
+        else {
+            this.focusGrid();
+        }
+    };
+    focusGrid() {
+        requestAnimationFrame(() => this.focusedButtonRef?.focus());
+    }
+    handlePopoverOpen = (ev) => {
+        ev.stopPropagation();
+        console.log('emitting open event');
+        this.lmvzOpen.emit();
+        if (this.pendingGridFocus) {
+            this.pendingGridFocus = false;
+            this.focusGrid();
+        }
+    };
+    handlePopoverClose = (ev) => {
+        console.log('handlePopoverClose', ev);
+        ev.stopPropagation();
+        this.open = false;
+        this.lmvzClose.emit();
+    };
+    updateFormState() {
+        const isoValue = this.value;
+        this.internals.setFormValue?.(isoValue ?? null);
+        const flags = {};
+        if (this.required && !this.valueDate) {
+            flags.valueMissing = true;
+        }
+        if (this.hasUnparseableInput) {
+            flags.badInput = true;
+        }
+        if (this.valueDate) {
+            const minDate = parseIsoDateSafely(this.min);
+            const maxDate = parseIsoDateSafely(this.max);
+            if (minDate && compare$1(this.valueDate, minDate) < 0)
+                flags.rangeUnderflow = true;
+            if (maxDate && compare$1(this.valueDate, maxDate) > 0)
+                flags.rangeOverflow = true;
+        }
+        const isInvalid = Object.values(flags).some(Boolean);
+        this.isInvalid = isInvalid;
+        if (!isInvalid) {
+            this.nativeError = false;
+        }
+        const validationLabels = getValidationLabels(this.locale);
+        this.internals.setValidity?.(flags, isInvalid ? this.errorMessage || validationLabels.invalidDateMessage : undefined, isInvalid ? this.el : undefined);
+    }
+    handleInvalid() {
+        this.nativeError = true;
+    }
+    isInvalid = false;
+    nativeError = false;
+    get effectivePlaceholder() {
+        return this.placeholder ?? derivePatternFromLocale(this.locale).toLowerCase();
+    }
+    renderHeader() {
+        const { locale } = this;
+        const vm = this.effectiveVisibleMonth;
+        const navLabels = getNavLabels(locale);
+        const monthYearLabel = toLocaleString(toPlainDate(vm, { day: 1 }), locale, { month: 'long', year: 'numeric' });
+        const prevMonth = addMonths(vm, -1);
+        const nextMonth = addMonths(vm, 1);
+        const minYM = this.min ? fromString(this.min.slice(0, 7), getBasic) : undefined;
+        const maxYM = this.max ? fromString(this.max.slice(0, 7), getBasic) : undefined;
+        const isPrevDisabled = this.disabled || (minYM !== undefined && compare(prevMonth, minYM) < 0);
+        const isNextDisabled = this.disabled || (maxYM !== undefined && compare(nextMonth, maxYM) > 0);
+        return (hAsync("div", { part: "header", class: "datepicker-header" }, hAsync("lmvz-button", { part: "nav-prev", variant: "tertiary", scale: "small", "aria-label": navLabels.prev, disabled: isPrevDisabled, onLmvzActivation: () => this.navigateMonth(-1, true) }, hAsync("lmvz-icon", { icon: CHEVRON_LEFT, "aria-hidden": "true" })), hAsync("span", { id: this.monthLabelId, part: "month-label", class: "datepicker-month-label" }, monthYearLabel), hAsync("lmvz-button", { part: "nav-next", variant: "tertiary", scale: "small", "aria-label": navLabels.next, disabled: isNextDisabled, onLmvzActivation: () => this.navigateMonth(1, true) }, hAsync("lmvz-icon", { icon: CHEVRON_RIGHT, "aria-hidden": "true" }))));
+    }
+    renderWeekdayRow() {
+        const { locale } = this;
+        const mondayFirstDows = [1, 2, 3, 4, 5, 6, 7];
+        const refMonday = fromFields({ year: 2024, month: 1, day: 1 });
+        return (hAsync("div", { part: "weekday-row", role: "row", class: "datepicker-weekday-row" }, mondayFirstDows.map((dow) => {
+            const refDate = addDays(refMonday, dow - 1);
+            const shortName = toLocaleString(refDate, locale, { weekday: 'short' });
+            const longName = toLocaleString(refDate, locale, { weekday: 'long' });
+            return (hAsync("span", { part: "weekday", role: "columnheader", "aria-label": longName, class: "datepicker-weekday", key: dow }, hAsync("abbr", { title: longName }, shortName)));
+        })));
+    }
+    renderGrid() {
+        const { locale, focusedDate } = this;
+        const vm = this.effectiveVisibleMonth;
+        const selectedDate = this.valueDate;
+        const minDate = parseIsoDateSafely(this.min);
+        const maxDate = parseIsoDateSafely(this.max);
+        const grid = (this.visibleDays = buildCalendarGrid(vm));
+        const weekdayAriaLabelFormatter = {
+            weekday: 'long',
+            day: 'numeric',
+            month: 'long',
+            year: 'numeric',
+        };
+        const weeks = [];
+        for (let w = 0; w < 6; w++) {
+            if (!grid.at(w * 7))
+                break;
+            weeks.push(grid.slice(w * 7, w * 7 + 7));
+        }
+        return (hAsync("div", { part: "grid", role: "grid", "aria-labelledby": this.monthLabelId, class: "datepicker-grid" }, this.renderWeekdayRow(), weeks.map((week, wi) => (hAsync("div", { part: "week-row", role: "row", class: "datepicker-week-row", key: wi }, week.map((date) => {
+            const iso = toIsoDateString(date);
+            const isTodayDate = compare$1(date, plainDateISO()) === 0;
+            const isSelectedDate = isSelected(date, selectedDate);
+            const isOutOfMonth = compare(toPlainYearMonth(date), vm) !== 0;
+            const isDisabledDate = this.readonly || isDisabled(date, minDate, maxDate);
+            const isFocused = focusedDate !== undefined && compare$1(date, focusedDate) === 0;
+            const partMarkers = ['day'];
+            if (isTodayDate)
+                partMarkers.push('day--today');
+            if (isSelectedDate)
+                partMarkers.push('day--selected');
+            if (isOutOfMonth)
+                partMarkers.push('day--out-of-month');
+            if (isDisabledDate)
+                partMarkers.push('day--disabled');
+            const ariaLabel = toLocaleString(date, locale, weekdayAriaLabelFormatter);
+            let fromRender = false;
+            let buttonRef;
+            if (isFocused) {
+                requestAnimationFrame(() => {
+                    const activeEl = this.el.shadowRoot?.activeElement;
+                    if (!(activeEl instanceof HTMLButtonElement) || activeEl.getAttribute('role') !== 'gridcell')
+                        return;
+                    fromRender = true;
+                    buttonRef?.focus();
+                });
+            }
+            return (hAsync("button", { "data-debug-id": iso, role: "gridcell", type: "button", part: partMarkers.join(' '), tabIndex: isFocused ? 0 : -1, "aria-label": ariaLabel, "aria-selected": isSelectedDate ? 'true' : undefined, "aria-current": isTodayDate ? 'date' : undefined, "aria-disabled": isDisabledDate ? 'true' : undefined, onClick: () => {
+                    if (isDisabledDate || this.disabled)
+                        return;
+                    this.selectDate(date, { origin: 'calendar', closePopover: true });
+                }, ref: (e) => {
+                    buttonRef = e;
+                    if (isFocused)
+                        this.focusedButtonRef = e;
+                }, onFocus: (e) => {
+                    console.log('focus event on grid cell', iso, e.target);
+                    if (!this.el.shadowRoot?.contains(e.target))
+                        return;
+                    if (fromRender) {
+                        fromRender = false;
+                        return;
+                    }
+                    this.setFocusedDate(date);
+                }, key: iso }, date.day));
+        }))))));
+    }
+    render() {
+        const validationLabels = getValidationLabels(this.locale);
+        const popoverLabel = this.label ? `${this.label} ${validationLabels.popoverSuffix}` : undefined;
+        return (hAsync(Host, { key: 'af9d7f075bf97d7eb58c6557f43cf8a245d5f712' }, hAsync("lmvz-input", { key: 'eef4be58281b8356d443c65c5cf6451192e70f75', ref: (el) => {
+                this.inputEl = el;
+            }, label: this.label ?? '', placeholder: this.effectivePlaceholder, helperText: this.helperText, errorMessage: this.errorMessage, error: this.nativeError, disabled: this.disabled, readonly: this.readonly, required: this.required, value: this.inputText, autocomplete: "off", onLmvzInput: this.handleInputTextChange, onKeyDown: this.handleInputKeydown }, hAsync("lmvz-icon", { key: 'fc39ef14720522a8089d33321b918e5577a36cc2', slot: "after-input", icon: CALENDAR_ICON, "aria-hidden": "true" })), hAsync("lmvz-popover", { key: '0076c57da02c7c9d0fcb53584f9dc4127317d6a5', anchor: this.inputEl, open: this.open && !this.disabled, autoFocus: false, size: "md", label: popoverLabel, onLmvzOpen: this.handlePopoverOpen, onLmvzClose: this.handlePopoverClose }, hAsync("div", { key: '4c1e716e52a5d9ed75155dded3c2c39649e1e844', part: "panel", class: "datepicker-panel" }, this.renderHeader(), this.renderGrid()))));
+    }
+    static get delegatesFocus() { return true; }
+    static get formAssociated() { return true; }
+    static get watchers() { return {
+        "required": [{
+                "handleValidityRelevantPropChange": 0
+            }],
+        "min": [{
+                "handleValidityRelevantPropChange": 0
+            }],
+        "max": [{
+                "handleValidityRelevantPropChange": 0
+            }],
+        "locale": [{
+                "handleDisplayFormatChange": 0
+            }],
+        "displayFormat": [{
+                "handleDisplayFormatChange": 0
+            }],
+        "disabled": [{
+                "handleDisabledChange": 0
+            }]
+    }; }
+    static get style() { return lmvzDatepickerCss(); }
+    static get cmpMeta() { return {
+        "$flags$": 601,
+        "$tagName$": "lmvz-datepicker",
+        "$members$": {
+            "value": [6145],
+            "visibleMonth": [6145, "visible-month"],
+            "min": [1],
+            "max": [1],
+            "locale": [1],
+            "firstDayOfWeek": [2, "first-day-of-week"],
+            "disabled": [516],
+            "readonly": [516],
+            "required": [516],
+            "name": [513],
+            "label": [1],
+            "placeholder": [1],
+            "helperText": [1, "helper-text"],
+            "errorMessage": [1, "error-message"],
+            "open": [1540],
+            "displayFormat": [1, "display-format"],
+            "focusedDate": [32],
+            "valueDate": [32],
+            "visibleMonthDate": [32],
+            "inputText": [32],
+            "hasUnparseableInput": [32],
+            "isInvalid": [32],
+            "nativeError": [32],
+            "checkValidity": [64],
+            "reportValidity": [64]
         },
-        "$listeners$": undefined,
+        "$listeners$": [[0, "keydown", "handleKeydown"], [0, "focusin", "handleInputFocus"], [0, "click", "handleInputFocus"], [0, "invalid", "handleInvalid"]],
         "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["type", "type"], ["size", "size"]]
+        "$attrsToReflect$": [["disabled", "disabled"], ["readonly", "readonly"], ["required", "required"], ["name", "name"], ["open", "open"]]
     }; }
 }
 
@@ -9084,7 +11928,7 @@ class LmvzHeader extends ReactiveControllerHost {
         }
     }
     render() {
-        return (hAsync(Host, { key: 'ce4b8cf9f7687e4af97d45908e2f0e484b90684f', onFocus: this.delegateFocus.bind(this) }, hAsync("div", { key: 'a2213d8038d126e47262c4ec18071dd4302152db', class: "brand" }, hAsync("slot", { key: '68a0a1e2b21859d78d2f9a7d3f5c86020c52c225', name: "brand" }, hAsync("img", { key: 'd0a878bc4c9f7a3460e857fb5aa52f1d942a0423', id: "fallback-logo-lmvz", src: logoSvg, alt: "Lehrmittelverlag Z\u00FCrich" }))), hAsync("nav", { key: '687791624d6ced477bc0cce73ce97b26c7d03af0', "aria-label": "Hauptnavigation" }, hAsync("div", { key: 'a9e8fa4a57e619a3d3b1056bfc0d5df74e89f630', role: "menubar", class: "primary-menubar" }, hAsync("slot", { key: 'f75f0a3bed2267aff902490f1905c67ad1b7e6be', name: "nav-primary", ref: (el) => (this.primarySlot = el) }), hAsync("div", { key: '3cf2d099bed99e4ba7b32a2f3171c69663785012', role: "menu", id: "nav-secondary", class: "secondary-menubar", hidden: !this.lmvzActiveNav, ref: (el) => (this.secondaryNav = el) }, hAsync("slot", { key: '85dbe77ea8ab62aa400640495e11e2d174ca5210', name: this.secondarySlotName, ref: (el) => (this.secondarySlot = el) })))), hAsync("div", { key: 'cf5d135a5b969af6a2bbb5432a10f8e1b9af1dca', class: "actions" }, hAsync("slot", { key: '1a0323668942151c071a24238039c7a216358363', name: "actions" }))));
+        return (hAsync(Host, { key: '77744fd74160551232eb0347e9ebb01eb3b9bec0', onFocus: this.delegateFocus.bind(this) }, hAsync("div", { key: 'dfd78b2a2ab06b010d9f29dd61f57aced82243fe', class: "brand" }, hAsync("slot", { key: 'c6d29bbdbcbe581a8a170fbeb3d6ab1e31d27dcd', name: "brand" }, hAsync("img", { key: '80cea3b254d153411864d52c2ba300e0eb3c57a7', id: "fallback-logo-lmvz", src: logoSvg, alt: "Lehrmittelverlag Z\u00FCrich" }))), hAsync("nav", { key: '71c53ae0300b61291d0763cdb23f1f645a83928a', "aria-label": "Hauptnavigation" }, hAsync("div", { key: '09949b77a66c54a10c4c141de846fd5697b9d445', role: "menubar", class: "primary-menubar" }, hAsync("slot", { key: 'acec0cf7e13325c49d1e0929b90b056ad1cbbe64', name: "nav-primary", ref: (el) => (this.primarySlot = el) }), hAsync("div", { key: 'd35860c71ad5e28ee2e3aaafb157acbeff41d83e', role: "menu", id: "nav-secondary", class: "secondary-menubar", hidden: !this.lmvzActiveNav, ref: (el) => (this.secondaryNav = el) }, hAsync("slot", { key: 'a4c3a1ad1b1de5bd903b54ed6bd1616ce6517bbb', name: this.secondarySlotName, ref: (el) => (this.secondarySlot = el) })))), hAsync("div", { key: 'ff50045d9ab28bf66a619a48d9ea1f0ed2f5f952', class: "actions" }, hAsync("slot", { key: '6ead0b7a54bf93bb06f0eab2aa8159bd6e96e8f5', name: "actions" }))));
     }
     static get watchers() { return {
         "lmvzActiveNav": [{
@@ -9153,7 +11997,7 @@ class LmvzIcon extends ReactiveControllerHost {
         super.componentDidRender();
     }
     render() {
-        return hAsync(Host, { key: '4fba217d573d968951819f12af24d775c8ac62dc', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
+        return hAsync(Host, { key: 'be6032d11399289c3baddd63ebc7d9e1fb98b773', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
     }
     waitUntilVisible(callback, rootMargin = 50) {
         {
@@ -9216,7 +12060,7 @@ const hasLazyBuild = (stencilEl) => {
     return stencilEl.componentOnReady !== undefined;
 };
 
-const lmvzInputCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-input-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);      --input-radius: var(--lmvz-component-input-radius-default, 999px);   --input-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --input-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --input-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --input-border-color-focus: var(--lmvz-semantic-color-border-active, #0f8acc);   --input-border-width: var(--lmvz-semantic-border-width-default, 1px);       --input-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --input-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --input-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --input-font-size: var(--lmvz-component-body-md-font-size, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));    --label-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --input-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --helper-text-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --error-text-color: var(--lmvz-semantic-color-status-on-danger, #a31419);    --label-minimized-bg: var(--input-bg);   --label-minimized-padding-x: 4px;       --input-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  [size='sm'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem));   --input-padding-x: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --input-gap: var(--lmvz-component-input-gap-sm, clamp(0.38rem, 0.31rem + 0.26vw, 0.63rem));   --input-font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='md'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --input-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --input-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --input-font-size: var(--lmvz-component-body-md-font-size, clamp(0.88rem, 0.84rem + 0.13vw, 1rem)); } [size='lg'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-lg, clamp(2.75rem, 2.69rem + 0.26vw, 3rem));   --input-padding-x: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --input-gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --input-font-size: var(--lmvz-component-body-lg-font-size, clamp(1rem, 0.97rem + 0.13vw, 1.13rem)); } .input-container.sc-lmvz-input {   display: flex;   flex-direction: column;   position: relative;   width: 100%; } .input-wrapper.sc-lmvz-input {   background-color: var(--input-bg);   border: var(--input-border-width) solid var(--input-border-color);   border-radius: var(--input-radius);   display: flex;   align-items: center;   height: var(--input-height);   padding: 0 var(--input-padding-x);   position: relative;   transition: border-color 0.2s ease;   gap: var(--input-gap); } [disabled].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   opacity: var(--input-disabled-opacity);   cursor: not-allowed;   pointer-events: none; } .input-container.sc-lmvz-input:focus-within .input-wrapper.sc-lmvz-input {   border-color: var(--input-border-color-focus);   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); }  [error].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color); }  .sc-lmvz-input-h:not([disabled]) .input-wrapper.sc-lmvz-input:hover {   border-color: var(--input-border-color-hover); } .label-input-group.sc-lmvz-input {   position: relative;   flex-grow: 1;   display: flex;   align-items: center;   height: 100%; } label.sc-lmvz-input {   position: absolute;   left: 0;   top: 50%;   transform: translateY(-50%);   color: var(--label-color);   font-size: var(--input-font-size);   font-weight: 400;   pointer-events: none;   transition: all 0.2s ease-out;   background-color: transparent;   padding: 0;   margin: 0;   line-height: 1.5;   white-space: nowrap; } label.floating.sc-lmvz-input {   top: 0.5em;   transform: translateY(-100%);   transform-origin: left top;   font-size: var(--lmvz-component-body-2xs-font-size, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem));   background-color: var(--label-minimized-bg);   padding: 0 var(--label-minimized-padding-x);   left: -2px;    color: var(--input-text-color);    font-weight: 400; } .required-indicator.sc-lmvz-input {   color: var(--error-text-color);   margin-left: 2px; } input.sc-lmvz-input {   border: none;   background: transparent;   width: 100%;   height: 100%;   color: var(--input-text-color);   font-family: inherit;   font-size: var(--input-font-size);   outline: none;   padding: 0;   margin: 0;   font-weight: 400; } input.sc-lmvz-input::placeholder {   color: var(--label-color); } div.sc-lmvz-input:empty {   display: none; } [role='status'].sc-lmvz-input {   padding-top: 8px;    padding-left: var(--input-padding-x);   font-size: 12px;   color: var(--helper-text-color);   font-weight: 400; } [role='alert'].sc-lmvz-input {   padding-top: 8px;   padding-left: var(--input-padding-x);   font-size: 12px;   color: var(--error-text-color);   font-weight: 400; } .sc-lmvz-input-s > lmvz-button {      --lmvz-button-padding: var(--lmvz-dimension-6-4, clamp(0.25rem, 0.22rem + 0.13vw, 0.38rem));   --lmvz-button-min-height-override: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem)); }`;
+const lmvzInputCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-input-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);      --input-radius: var(--lmvz-component-input-radius-default, 999px);   --input-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --input-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --input-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --input-border-color-focus: var(--lmvz-semantic-color-border-active, #0f8acc);   --input-border-width: var(--lmvz-semantic-border-width-default, 1px);       --input-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --input-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --input-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --input-font-size: var(--lmvz-component-body-md-font-size, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));    --label-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --input-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --helper-text-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --error-text-color: var(--lmvz-semantic-color-status-on-danger, #a31419);    --label-minimized-bg: var(--input-bg);   --label-minimized-padding-x: 4px;       --input-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  [size='sm'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem));   --input-padding-x: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --input-gap: var(--lmvz-component-input-gap-sm, clamp(0.38rem, 0.31rem + 0.26vw, 0.63rem));   --input-font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='md'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --input-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --input-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --input-font-size: var(--lmvz-component-body-md-font-size, clamp(0.88rem, 0.84rem + 0.13vw, 1rem)); } [size='lg'].sc-lmvz-input-h {   --input-height: var(--lmvz-component-input-size-lg, clamp(2.75rem, 2.69rem + 0.26vw, 3rem));   --input-padding-x: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --input-gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --input-font-size: var(--lmvz-component-body-lg-font-size, clamp(1rem, 0.97rem + 0.13vw, 1.13rem)); } .input-container.sc-lmvz-input {   display: flex;   flex-direction: column;   position: relative;   width: 100%; } .input-wrapper.sc-lmvz-input {   background-color: var(--input-bg);   border: var(--input-border-width) solid var(--input-border-color);   border-radius: var(--input-radius);   display: flex;   align-items: center;   height: var(--input-height);   padding: 0 var(--input-padding-x);   position: relative;   transition: border-color 0.2s ease;   gap: var(--input-gap); } [disabled].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   opacity: var(--input-disabled-opacity);   cursor: not-allowed;   pointer-events: none; } .sc-lmvz-input-h:has(:focus-visible) .input-wrapper.sc-lmvz-input {   border-color: var(--input-border-color-focus);   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); }  [error].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color); }  .sc-lmvz-input-h:not([disabled]) .input-wrapper.sc-lmvz-input:hover {   border-color: var(--input-border-color-hover); } .label-input-group.sc-lmvz-input {   position: relative;   flex-grow: 1;   display: flex;   align-items: center;   height: 100%; } label.sc-lmvz-input {   position: absolute;   left: 0;   top: 50%;   transform: translateY(-50%);   color: var(--label-color);   font-size: var(--input-font-size);   font-weight: 400;   pointer-events: none;   transition: all 0.2s ease-out;   background-color: transparent;   padding: 0;   margin: 0;   line-height: 1.5;   white-space: nowrap; } label.floating.sc-lmvz-input {   top: 0.5em;   transform: translateY(-100%);   transform-origin: left top;   font-size: var(--lmvz-component-body-2xs-font-size, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem));   background-color: var(--label-minimized-bg);   padding: 0 var(--label-minimized-padding-x);   left: -2px;    color: var(--input-text-color);    font-weight: 400; } .required-indicator.sc-lmvz-input {   color: var(--error-text-color);   margin-left: 2px; } input.sc-lmvz-input {   border: none;   background: transparent;   width: 100%;   height: 100%;   color: var(--input-text-color);   font-family: inherit;   font-size: var(--input-font-size);   outline: none;   padding: 0;   margin: 0;   font-weight: 400; } input.sc-lmvz-input::placeholder {   color: var(--label-color); } div.sc-lmvz-input:empty {   display: none; } [role='status'].sc-lmvz-input {   padding-top: 8px;    padding-left: var(--input-padding-x);   font-size: 12px;   color: var(--helper-text-color);   font-weight: 400; } [role='alert'].sc-lmvz-input {   padding-top: 8px;   padding-left: var(--input-padding-x);   font-size: 12px;   color: var(--error-text-color);   font-weight: 400; } .sc-lmvz-input-s > lmvz-button {      --lmvz-button-padding: var(--lmvz-dimension-6-4, clamp(0.25rem, 0.22rem + 0.13vw, 0.38rem));   --lmvz-button-min-height-override: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem)); }`;
 
 let inputIdCounter = 0;
 class LmvzInput extends ReactiveControllerHost {
@@ -9226,9 +12070,11 @@ class LmvzInput extends ReactiveControllerHost {
     }
     lmvzInput;
     internals;
+    inputValidityActive = false;
     nativeInputElement;
     inputId = `lmvz-input-${inputIdCounter++}`;
     initialValue = '';
+    ariaHostMirrorObserver;
     nativeError = false;
     errorFromProp = false;
     get helperId() {
@@ -9281,7 +12127,7 @@ class LmvzInput extends ReactiveControllerHost {
     async setValue(newValue) {
         const input = this.nativeInputElement;
         const val = newValue ?? '';
-        if (input) {
+        if (input && input.value !== val) {
             input.value = val;
         }
         this.value = val;
@@ -9303,6 +12149,9 @@ class LmvzInput extends ReactiveControllerHost {
     async reportValidity() {
         return this.nativeInputElement?.reportValidity?.() ?? false;
     }
+    async getValidationMessage() {
+        return this.nativeInputElement?.validationMessage ?? '';
+    }
     async getInputElement() {
         if (!this.nativeInputElement) {
             await new Promise((resolve) => componentOnReady(this.el, resolve));
@@ -9328,14 +12177,54 @@ class LmvzInput extends ReactiveControllerHost {
         this.initialValue = this.value ?? '';
         super.componentWillLoad();
     }
+    connectedCallback() {
+        super.connectedCallback();
+        this.ariaHostMirrorObserver = new MutationObserver((mutations) => {
+            for (const mutation of mutations) {
+                this.mirrorHostAriaAttribute(mutation.attributeName);
+            }
+        });
+        this.ariaHostMirrorObserver.observe(this.el, {
+            attributes: true,
+            attributeFilter: [...ariaHostMirrorAttributes],
+        });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.ariaHostMirrorObserver?.disconnect();
+        this.ariaHostMirrorObserver = undefined;
+    }
+    componentDidLoad() {
+        super.componentDidLoad();
+        for (const attr of ariaHostMirrorAttributes) {
+            this.mirrorHostAriaAttribute(attr);
+        }
+    }
+    mirrorHostAriaAttribute(attr) {
+        if (!attr || !this.nativeInputElement)
+            return;
+        if (this.el.hasAttribute(attr)) {
+            const value = this.el.getAttribute(attr);
+            if (value !== null) {
+                this.nativeInputElement.setAttribute(attr, value);
+            }
+        }
+        else {
+            this.nativeInputElement.removeAttribute(attr);
+        }
+    }
     formAssociatedCallback(form) {
         if (!form)
             return;
         this.internals.setFormValue?.(this.value ?? '');
     }
     formResetCallback() {
+        this.inputValidityActive = false;
         this.internals.setValidity({});
         this.setValue(this.initialValue);
+        if (this.nativeInputElement?.checkValidity?.()) {
+            this.nativeError = false;
+        }
     }
     formStateRestoreCallback(state) {
         this.setValue(state);
@@ -9349,35 +12238,45 @@ class LmvzInput extends ReactiveControllerHost {
         this.setValue(newValue);
     }
     handleDisabledChange(disabled) {
-        if (disabled && this.nativeInputElement) {
+        if (!this.nativeInputElement)
+            return;
+        if (disabled) {
             this.nativeInputElement.blur();
         }
+        else {
+            this.inputValidityActive = false;
+        }
     }
     handleInput = (event) => {
         const input = event.target;
         this.setValue(input.value);
+        if (!this.inputValidityActive)
+            return;
+        this.updateNativeError('input');
     };
     handleChange = (event) => {
-        const input = event.target ?? this.nativeInputElement;
-        this.updateNativeError(input);
     };
     handleFocus = () => { };
-    handleBlur = (event) => {
-        const input = event.target;
-        input.checkValidity?.();
+    handleInvalid = () => this.updateNativeError('invalid');
+    handleBlur = () => {
+        this.inputValidityActive = true;
+        this.updateNativeError('blur');
     };
-    updateNativeError(fromEvent) {
-        const input = fromEvent ?? this.nativeInputElement;
+    updateNativeError(sourceEvent) {
+        const input = this.nativeInputElement;
         if (!input)
             return;
-        this.nativeError = !(input.checkValidity?.() ?? true);
+        const newState = sourceEvent === 'invalid' ? true : !(input.checkValidity?.() ?? true);
+        if (this.nativeError === newState)
+            return;
+        this.nativeError = newState;
     }
     render() {
         const hasValue = Boolean(this.value);
         const shouldFloatLabel = hasValue || Boolean(this.placeholder);
-        return (hAsync("div", { key: '693614c334a94373dcef56b461455bf872249a69', class: classNames('input-container', {
+        return (hAsync("div", { key: '626697f00e9ba3ad46e6304d06b04df0f27bb2c2', class: classNames('input-container', {
                 'interaction-filled': hasValue,
-            }) }, hAsync("div", { key: '0eb36d76661d70bea71027ca7b30763d89bd6cb6', class: "input-wrapper" }, hAsync("slot", { key: '03adf18ebe01fe70dc821dcea2bb2963df40f8b4', name: "before-input" }), hAsync("div", { key: 'f1254561b53e321d0f2e4cf4ac93936119083f3f', class: "label-input-group" }, hAsync("label", { key: 'e17cdec368fd36a041d9d8853f4a82249f1b5d8c', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (hAsync("span", { key: 'b3e003bf972c3ad5b6c5b25f8ee509bd5d8df758', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), hAsync("input", { key: '75f192118b7a4c3e507172e13d0ae7e32118aad3', id: this.inputId, ref: (el) => (this.nativeInputElement = el), type: this.type, min: this.min, max: this.max, step: this.step, value: this.value, name: this.name, placeholder: this.placeholder, disabled: this.disabled, readOnly: this.readonly, required: this.required, form: this.form, autocomplete: this.autocomplete, inputmode: this.inputmode, autocorrect: this.autocorrect, autocapitalize: this.autocapitalize, spellcheck: this.spellcheck, autofocus: this.autofocus, minlength: this.minlength, maxlength: this.maxlength, pattern: this.pattern, "aria-invalid": this.error ? 'true' : 'false', "aria-required": this.required ? 'true' : 'false', "aria-describedby": this.describedBy, "aria-errormessage": this.errorId, onInput: this.handleInput, onChange: this.handleChange, onFocus: this.handleFocus, onBlur: this.handleBlur })), hAsync("slot", { key: '58a9701259ca92fd7441c1480de741d92bc47bc9', name: "after-input" })), hAsync("div", { key: '396b719d080c781f38d736e28e9c048f629d6ffe', id: this.helperId, role: "status" }, this.helperText || null), hAsync("div", { key: '9e5c86e6098f58d95c0984348d3da07b9e34e1fb', id: this.errorId, role: "alert" }, (this.showErrorMessage && this.errorMessage) || null)));
+            }) }, hAsync("div", { key: '25ec1f448b689ff80defded1323f321d95d6b197', class: "input-wrapper" }, hAsync("slot", { key: '1d5f301e0327b4cd1714f403615f94658a754466', name: "before-input" }), hAsync("div", { key: 'ef553e6e8f6b74a5bb7cddef003d3b51650c7c9d', class: "label-input-group" }, hAsync("label", { key: '17d92ff7c65598739e8a379680580561936e21dc', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (hAsync("span", { key: 'cd40da3c85cc6cea49d7d8d270bba317534779f5', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), hAsync("input", { key: '3ede0644d383c2a3f702230de2aac6fbcb2c7a06', id: this.inputId, ref: (el) => (this.nativeInputElement = el), type: this.type, min: this.min, max: this.max, step: this.step, value: this.value, name: this.name, placeholder: this.placeholder, disabled: this.disabled, readonly: this.readonly, required: this.required, form: this.form, autocomplete: this.autocomplete, inputmode: this.inputmode, autocorrect: this.autocorrect, autocapitalize: this.autocapitalize, spellcheck: this.spellcheck, autofocus: this.autofocus, minlength: this.minlength, maxlength: this.maxlength, pattern: this.pattern, "aria-invalid": this.error ? 'true' : 'false', "aria-required": this.required ? 'true' : 'false', "aria-describedby": this.describedBy, "aria-errormessage": this.errorId, onInput: this.handleInput, onChange: this.handleChange, onFocus: this.handleFocus, onBlur: this.handleBlur, onInvalid: this.handleInvalid })), hAsync("slot", { key: 'b282c5d9553b72af7fd05ed0f872af0d7b8a5689', name: "after-input" })), hAsync("div", { key: 'da6008e798cb5ee29fa7d1ba3208057c1845a217', id: this.helperId, role: "status" }, this.helperText || null), hAsync("div", { key: '5e7717a2d0dd32c53dd7ba6e170152239f3bfae9', id: this.errorId, role: "alert" }, (this.showErrorMessage && this.errorMessage) || null)));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -9425,6 +12324,7 @@ class LmvzInput extends ReactiveControllerHost {
             "select": [64],
             "checkValidity": [64],
             "reportValidity": [64],
+            "getValidationMessage": [64],
             "getInputElement": [64]
         },
         "$listeners$": undefined,
@@ -9483,7 +12383,7 @@ class LmvzLink {
         const rel = this.computeRel();
         const iconSvg = this.type === 'external' ? EXTERNAL_SVG : ARROW_RIGHT_SVG;
         const isBlank = this.target === '_blank';
-        return (hAsync(Host, { key: '338116d5af3112ec2a4a09b652048b733565a7d4' }, hAsync("a", { key: 'ae70aa2320ea2eeca56a14714de4dcfb06b8c94c', href: this.computeHref(), target: this.target, rel: rel }, hAsync("slot", { key: '4852b3336a94a46f363a83fb2c4f6d267f680d3d' }), hAsync("lmvz-icon", { key: 'e7f72016611a7d741eef7c81a047e026c699bdef', "aria-hidden": "true", icon: iconSvg }), isBlank && hAsync("span", { key: 'b4138b479b7c36c3b16c8e96fc6e39736222b26f', class: "sr-only" }, this.externalLabel))));
+        return (hAsync(Host, { key: 'ee4f5c107243ff858f9189840e56a0525fdac782' }, hAsync("a", { key: '28229373bec276579c2bb7b9fcf254872baae9e8', href: this.computeHref(), target: this.target, rel: rel }, hAsync("slot", { key: '7c58f3f7501e457ee4a35d2a9f2bf80ed0c33fb0' }), hAsync("lmvz-icon", { key: '14784743d148d57e7c83da0f92ba96e4bb3a30a1', "aria-hidden": "true", icon: iconSvg }), isBlank && hAsync("span", { key: 'f72adde57b462282d1a8313e2eb06cf6b68c2697', class: "sr-only" }, this.externalLabel))));
     }
     static get delegatesFocus() { return true; }
     static get watchers() { return {
@@ -9531,7 +12431,7 @@ class LmvzMenuItem extends ReactiveControllerHost {
         this.addController(new ElementActivationController(this));
     }
     render() {
-        return (hAsync(Host, { key: '9c86e99a0427a5d11925a30bcdb9f88124006413' }, hAsync("slot", { key: '9a578cdf49bd1edd981d68d7b28c39b784980345', ref: (e) => (this.validationSlot = e) })));
+        return (hAsync(Host, { key: 'cd5814d6bcfa9b0f5b1b2f5108ce0fc65722b909' }, hAsync("slot", { key: 'b503b252c95bc09ca4b888d4576badd3976292e9', ref: (e) => (this.validationSlot = e) })));
     }
     static get style() { return lmvzMenuitemCss(); }
     static get cmpMeta() { return {
@@ -9649,7 +12549,7 @@ class LmvzMessage {
     }
     render() {
         const role = this.live === 'assertive' ? 'alert' : this.live === 'polite' ? 'status' : 'note';
-        return (hAsync(Host, { key: '99dad82a6300fb8d089f1ea688186d4b4316a058', role: role }, this.leadingIcon && hAsync("span", { key: '2adf33102f7075a83ebf29d9b6e0d433a17beb68', class: "leading-icon", "aria-hidden": "true", innerHTML: TYPE_SVG[this.type] }), hAsync("span", { key: '286d3d0ea065534b84be18c927b2fcd7f30f34bd', class: "message" }, hAsync("slot", { key: '261e865980515a816382b2c7c6b3a52b500308bf', ref: (el) => (this.messageSlot = el), onSlotchange: this.handleSlotChange })), this.actionLabel && (hAsync("lmvz-button", { key: '46d964c0490bbdd47426fc228db0e3ccb108b416', variant: "tertiary", scale: "small", onLmvzActivation: this.handleActionClick }, this.actionLabel)), this.dismissible && (hAsync("lmvz-button", { key: 'ce1ec8beb756c2e11c948e227f94f81bd5568c88', variant: "tertiary", scale: "small", "aria-label": this.closeLabel, onClick: this.handleDismissClick }, hAsync("lmvz-icon", { key: '5361c424e77ffea7984c2fd42357666cd86ba1d6', "aria-hidden": "true", icon: CLOSE_SM_SVG })))));
+        return (hAsync(Host, { key: '1c45cf27f057535ffff047548a3d6681dd487d3c', role: role }, this.leadingIcon && hAsync("span", { key: '8efab69f677dfaa06d333aa304479e17e6d60ad6', class: "leading-icon", "aria-hidden": "true", innerHTML: TYPE_SVG[this.type] }), hAsync("span", { key: '2e88e9053444e2aae23341b7cba923c7c440ff64', class: "message" }, hAsync("slot", { key: 'd6b0ee6c95846a1de97e0e6ed707001c29c78c92', ref: (el) => (this.messageSlot = el), onSlotchange: this.handleSlotChange })), this.actionLabel && (hAsync("lmvz-button", { key: 'c55e38e274e98c8ac584ae16520fb0cab5e11d17', variant: "tertiary", scale: "small", onLmvzActivation: this.handleActionClick }, this.actionLabel)), this.dismissible && (hAsync("lmvz-button", { key: '1ae69fefbb23cd8a219aee1d624e9d7779ae0c08', variant: "tertiary", scale: "small", "aria-label": this.closeLabel, onClick: this.handleDismissClick }, hAsync("lmvz-icon", { key: '572c5b3309a1b1b9798dc6fc3f4ad11d0a354ebc', "aria-hidden": "true", icon: CLOSE_SM_SVG })))));
     }
     static get style() { return lmvzMessageCss(); }
     static get cmpMeta() { return {
@@ -9893,7 +12793,7 @@ class LmvzModal extends ReactiveControllerHost {
         this.hasHeader = this.hasAssignedContent(this.headerSlot);
     };
     render() {
-        return (hAsync(Host, { key: '8b5f506cdac223a440309d472639fe965b94f8c2' }, hAsync("dialog", { key: '0b70ac4d9590266271052c4d7fdef03c684d9b72', ref: (element) => (this.dialogEl = element), onCancel: this.handleDialogCancel, onClose: this.handleDialogClose, ...this.dialogAccessibilityAttributes }, hAsync("div", { key: '25b529bec1905408c2041b7370ab37586eade47d', class: "modal-shell" }, hAsync("header", { key: 'd86ae4a6f4ac7f6efd38385f1407d1f6bfbb1abb', class: { header: true, 'has-title': this.hasHeader } }, hAsync("div", { key: '7fd7059bfb0b90834895a87c2f2598e2e8c2ba80', class: "title", id: this.dialogTitleId, hidden: !this.hasHeader }, hAsync("slot", { key: 'b6eb7885e220e5def4c3c8420d5b83f4a7e30907', name: "header", ref: (element) => (this.headerSlot = element), onSlotchange: this.handleHeaderSlotChange })), hAsync("lmvz-button", { key: '72e17391097dfa756e572764f40080b6eec222b2', ref: (element) => (this.closeButtonEl = element), type: "button", class: "close-button", "aria-label": this.closeLabel, onLmvzActivation: this.handleCloseButtonClick, variant: "tertiary" }, hAsync("lmvz-icon", { key: '7bbae1aefa9ccc6646d5861683e3476339a545e4', icon: closeIconSvg }))), hAsync("div", { key: '9f22628448e9af527eb10ef2602c498afc55c029', class: "body" }, hAsync("slot", { key: '413e72707749b3abc987ef47a81cccda4b874c84' })), hAsync("footer", { key: 'a1a8f648e88d1f9045e9cf866d332aac69e033df', class: "actions", hidden: !this.buttonGroupEl?.hasActions }, hAsync("lmvz-button-group", { key: '7d7eeee7a2551a09bfb4fc513bde48828be5ee8b', ref: (element) => (this.buttonGroupEl = element) }, hAsync("slot", { key: '76b00523167c5fa08f11fc351a37638227401711', name: "actions" })))))));
+        return (hAsync(Host, { key: '9eb1aa89e4c682586d10291e2a8a2523b8fd17f7' }, hAsync("dialog", { key: '477c537328622f85759dc72a0c499d56e3d5e345', ref: (element) => (this.dialogEl = element), onCancel: this.handleDialogCancel, onClose: this.handleDialogClose, ...this.dialogAccessibilityAttributes }, hAsync("div", { key: 'b9fe9cb306938a117002e5213740ea20269080b8', class: "modal-shell" }, hAsync("header", { key: '34d0cd8078d55d98ec526843f02710044663de70', class: { header: true, 'has-title': this.hasHeader } }, hAsync("div", { key: '1408f0e0875f5e0508ad0f5682f4879a93df65df', class: "title", id: this.dialogTitleId, hidden: !this.hasHeader }, hAsync("slot", { key: '735c1757962e4f3804700a4669d0b49f2d11fb16', name: "header", ref: (element) => (this.headerSlot = element), onSlotchange: this.handleHeaderSlotChange })), hAsync("lmvz-button", { key: 'b0eb76cde508fb434023abdc0f764e1b809b6447', ref: (element) => (this.closeButtonEl = element), type: "button", class: "close-button", "aria-label": this.closeLabel, onLmvzActivation: this.handleCloseButtonClick, variant: "tertiary" }, hAsync("lmvz-icon", { key: '9f978d3117a4046202c3ba1df39aa0c7afc7ee28', icon: closeIconSvg }))), hAsync("div", { key: '46ffd7e7315099189c0a2499d17bdeabeb0e46e5', class: "body" }, hAsync("slot", { key: '095c3353f2ea00f6fa765ac0972ee0123f8e4154' })), hAsync("footer", { key: '5b092b00f10acede66d0fac53f01584ecf528418', class: "actions", hidden: !this.buttonGroupEl?.hasActions }, hAsync("lmvz-button-group", { key: 'ce312e1b1c3407838b8704f20393e7120d6338f9', ref: (element) => (this.buttonGroupEl = element) }, hAsync("slot", { key: '6246782cbee1cc440cfdaf45dac36655f19c972e', name: "actions" })))))));
     }
     static get watchers() { return {
         "open": [{
@@ -11272,7 +14172,7 @@ const computePosition = (reference, floating, options) => {
   });
 };
 
-const lmvzPopoverCss = () => `@layer lmvz-ds.reset,lmvz-ds.theme,lmvz-ds.components,lmvz-ds.overrides; @layer lmvz-ds.components{.lmvz-wrapper-card-sm,.lmvz-wrapper-card-md,.lmvz-wrapper-card-lg{background:var(--lmvz-semantic-color-surface-primary, #ffffff);box-shadow:var(--lmvz-ds-shadow-l3-default-strong, 0 2px 32px 0 rgba(120, 120, 128, 0.11))}.lmvz-wrapper-card-sm{padding:var(--lmvz-component-wrapper-sm-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)) var(--lmvz-component-wrapper-sm-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));border-radius:var(--lmvz-component-wrapper-sm-border-radius, 14px)}.lmvz-wrapper-card-md{padding:var(--lmvz-component-wrapper-md-padding-y, clamp(1rem, 0.88rem + 0.52vw, 1.5rem)) var(--lmvz-component-wrapper-md-padding-x, clamp(1rem, 0.88rem + 0.52vw, 1.5rem));border-radius:var(--lmvz-component-wrapper-md-border-radius, 18px)}.lmvz-wrapper-card-lg{padding:var(--lmvz-component-wrapper-lg-padding-y, clamp(2.25rem, 2.19rem + 0.26vw, 2.5rem)) var(--lmvz-component-wrapper-lg-padding-x, clamp(1.5rem, 1.14rem + 1.55vw, 3rem));border-radius:var(--lmvz-component-wrapper-lg-border-radius, 18px)}}:host{--lmvz-popover-z-index-internal:var(--lmvz-popover-z-index, 1);display:contents;.container{position:absolute;top:-9999999999px;left:-9999999999px;max-width:var(--lmvz-popover-max-width, none);max-height:var(--lmvz-popover-max-height, none);z-index:var(--lmvz-popover-z-index-internal);overflow:auto;box-sizing:border-box}}:host(:not([open])) .container{display:none}`;
+const lmvzPopoverCss = () => `@layer lmvz-ds.reset,lmvz-ds.theme,lmvz-ds.components,lmvz-ds.overrides; @layer lmvz-ds.components{.lmvz-wrapper-card-sm,.lmvz-wrapper-card-md,.lmvz-wrapper-card-lg{background:var(--lmvz-semantic-color-surface-primary, #ffffff);box-shadow:var(--lmvz-ds-shadow-l3-default-strong, 0 2px 32px 0 rgba(120, 120, 128, 0.11))}.lmvz-wrapper-card-sm{padding:var(--lmvz-component-wrapper-sm-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)) var(--lmvz-component-wrapper-sm-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));border-radius:var(--lmvz-component-wrapper-sm-border-radius, 14px)}.lmvz-wrapper-card-md{padding:var(--lmvz-component-wrapper-md-padding-y, clamp(1rem, 0.88rem + 0.52vw, 1.5rem)) var(--lmvz-component-wrapper-md-padding-x, clamp(1rem, 0.88rem + 0.52vw, 1.5rem));border-radius:var(--lmvz-component-wrapper-md-border-radius, 18px)}.lmvz-wrapper-card-lg{padding:var(--lmvz-component-wrapper-lg-padding-y, clamp(2.25rem, 2.19rem + 0.26vw, 2.5rem)) var(--lmvz-component-wrapper-lg-padding-x, clamp(1.5rem, 1.14rem + 1.55vw, 3rem));border-radius:var(--lmvz-component-wrapper-lg-border-radius, 18px)}}:host{--lmvz-popover-z-index-internal:var(--lmvz-popover-z-index, 100);display:contents;.container{position:absolute;top:-9999999999px;left:-9999999999px;max-width:var(--lmvz-popover-max-width, none);max-height:var(--lmvz-popover-max-height, none);z-index:var(--lmvz-popover-z-index-internal);overflow:auto;box-sizing:border-box}}:host(:not([open])) .container{display:none}`;
 
 class LmvzPopover {
     constructor(hostRef) {
@@ -11293,6 +14193,7 @@ class LmvzPopover {
     placement = 'bottom-start';
     size = 'sm';
     autoFocus = true;
+    containerRole = 'dialog';
     label;
     lmvzOpen;
     lmvzClose;
@@ -11313,6 +14214,7 @@ class LmvzPopover {
     }
     componentDidLoad() {
         autoAssignId(this.el);
+        this.syncContainerId();
     }
     handleOpenChange(isOpen) {
         if (isOpen) {
@@ -11339,16 +14241,26 @@ class LmvzPopover {
         this.removeCloseHandlers();
         this.extEventController.abort();
     }
+    syncContainerId() {
+        const hostId = this.el.getAttribute('id');
+        if (!hostId || !this.containerEl)
+            return;
+        this.containerEl.id = hostId;
+    }
     setupAnchorEl() {
         const { anchorEl } = this;
         if (!anchorEl) {
             console.warn('no anchor element set for', this);
             return;
         }
+        this.syncContainerId();
         if (!anchorEl.hasAttribute('aria-haspopup')) {
-            anchorEl.setAttribute('aria-haspopup', 'dialog');
+            anchorEl.setAttribute('aria-haspopup', this.containerRole === 'dialog' ? 'dialog' : this.containerRole);
+        }
+        anchorEl.setAttribute('aria-controls', this.containerEl?.id || this.el.getAttribute('id'));
+        if (!anchorEl.hasAttribute('aria-expanded')) {
+            anchorEl.setAttribute('aria-expanded', this.open ? 'true' : 'false');
         }
-        anchorEl.setAttribute('aria-controls', this.el.getAttribute('id'));
         if (isActionButton(anchorEl)) {
             addElementActivationListener(anchorEl, this.toggle.bind(this), this.extEventController.signal);
         }
@@ -11373,10 +14285,11 @@ class LmvzPopover {
         await waitFrame();
         await this.updatePosition();
         autoAssignId(this.el);
+        this.syncContainerId();
         this.applyAnchorAriaOpen();
         this.lmvzOpen.emit();
         await waitFrame();
-        if (this.autoFocus) {
+        if (this.autoFocus && this.containerRole === 'dialog') {
             this.focusFirst();
         }
     }
@@ -11434,7 +14347,8 @@ class LmvzPopover {
         document.addEventListener('mousedown', (event) => {
             if (!this.open)
                 return;
-            if (this.el.contains(event.target))
+            const mouseTarget = (event.target?.shadowRoot ?? document).elementFromPoint(event.x, event.y) ?? event.target;
+            if (this.el === event.target || this.el.contains(mouseTarget) || this.el.contains(event.target))
                 return;
             this.triggerClose();
         }, options);
@@ -11450,7 +14364,7 @@ class LmvzPopover {
         this.closureController?.abort();
     }
     render() {
-        return (hAsync(Host, { key: '744dae23d80c1e81a0b8bd2e9fcb02c6669d54cd' }, hAsync("div", { key: '7f40e25f1e05738b2bbf900b90613004eb188395', role: "dialog", part: "container", class: `container lmvz-wrapper-card-${this.size}`, "aria-label": this.label || undefined, ref: (el) => (this.containerEl = el) }, hAsync("slot", { key: '5a400fd9e697254007973f2dce172588fe3760ee', ref: (el) => (this.slotEl = el) }))));
+        return (hAsync(Host, { key: '8dadcc766deebc03ea744fd1002078b382bfd48d' }, hAsync("div", { key: 'd332714964212db6f5446afb1b8f38ff031a87b9', role: this.containerRole, part: "container", class: `container lmvz-wrapper-card-${this.size}`, "aria-label": this.label || undefined, ref: (el) => (this.containerEl = el) }, hAsync("slot", { key: '0fa1d214c8c48942751cbd4759ebc992eacc8f72', ref: (el) => (this.slotEl = el) }))));
     }
     static get watchers() { return {
         "open": [{
@@ -11470,6 +14384,7 @@ class LmvzPopover {
             "placement": [1],
             "size": [1],
             "autoFocus": [4, "auto-focus"],
+            "containerRole": [1, "container-role"],
             "label": [1],
             "anchorEl": [32],
             "show": [64],
@@ -11544,6 +14459,7 @@ class RadioGroup {
             if (wasEmpty) {
                 document.addEventListener('focusin', this._focusinHandler, true);
             }
+            this.refreshValidity();
         }
     }
     unregister(host) {
@@ -11554,10 +14470,19 @@ class RadioGroup {
         if (this.hosts.length === 0) {
             document.removeEventListener('focusin', this._focusinHandler, true);
         }
+        this.refreshValidity();
     }
     get sortedEnabled() {
         return this.hosts.filter((h) => !h.disabled);
     }
+    isAnyChecked() {
+        return this.hosts.some((host) => host.checked);
+    }
+    refreshValidity() {
+        for (const host of this.hosts) {
+            host.updateValidity();
+        }
+    }
     setFocused(host) {
         this._focusedHost = host;
         this.updateTabindex();
@@ -11573,6 +14498,7 @@ class RadioGroup {
             host.checked = host === selectedHost;
         }
         this.updateTabindex();
+        this.refreshValidity();
     }
     updateTabindex() {
         const enabled = this.sortedEnabled;
@@ -11634,6 +14560,12 @@ class RadioGroupController {
     select(selectedHost) {
         this.group?.select(selectedHost);
     }
+    isAnyChecked() {
+        return this.group?.isAnyChecked() ?? false;
+    }
+    refreshValidity() {
+        this.group?.refreshValidity();
+    }
     setFocused(host) {
         this.group?.setFocused(host);
     }
@@ -11676,7 +14608,7 @@ class RadioGroupController {
 
 const lmvzRadioCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-radio-h {   display: inline-block;    --radio-circle-size: var(--lmvz-global-s18, 18px);   --radio-dot-size: 0.5rem;    --radio-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --radio-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --radio-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --radio-border-color-checked: var(--lmvz-semantic-color-border-active, #0f8acc);   --radio-border-color-error: var(--lmvz-semantic-color-status-on-danger, #a31419);   --radio-dot-color: var(--lmvz-semantic-color-border-active, #0f8acc);    --radio-wrapper-bg-hover: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --radio-wrapper-bg-active: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0);    --radio-label-color: var(--lmvz-semantic-color-on-surface-primary, #000000);   --radio-label-color-checked: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --radio-helper-color: var(--lmvz-semantic-color-on-surface-secondary, #545454);    --radio-easing: var(--lmvz-global-easing-default, ease);   --radio-duration: 0.2s;    display: flex;   align-items: center;   gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   padding-block: var(--lmvz-dimension-8-2, clamp(0.13rem, 0.03rem + 0.39vw, 0.5rem));   padding-inline: var(--lmvz-dimension-12-8, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   border-radius: var(--lmvz-semantic-border-radius-round, 999px);   overflow: clip;   cursor: pointer;   background-color: transparent;   position: relative;   transition: background-color var(--radio-duration) var(--radio-easing); } input.sc-lmvz-radio {   position: absolute;   inset-block-start: var(--lmvz-dimension-8-2, clamp(0.13rem, 0.03rem + 0.39vw, 0.5rem));   inset-inline-start: var(--lmvz-dimension-10-4, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   opacity: 0;   width: var(--radio-circle-size);   height: var(--radio-circle-size);   margin: 0;   cursor: pointer;   z-index: 1; } .circle.sc-lmvz-radio {   width: var(--radio-circle-size);   height: var(--radio-circle-size);   border-radius: 50%;   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--radio-border-color);   background-color: var(--radio-bg);   pointer-events: none;   flex-shrink: 0;   display: flex;   align-items: center;   justify-content: center;   box-sizing: border-box;   transition: border-color var(--radio-duration) var(--radio-easing); } .dot.sc-lmvz-radio {   width: var(--radio-dot-size);   height: var(--radio-dot-size);   border-radius: 50%;   background-color: var(--radio-dot-color); } .content.sc-lmvz-radio {   display: flex;   flex-direction: column;   overflow-wrap: break-word;   min-width: 0; } label.sc-lmvz-radio {   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5 Router);   color: var(--radio-label-color);   cursor: pointer;   transition: color var(--radio-duration) var(--radio-easing); } .helper-text.sc-lmvz-radio {   display: block;   font: var(--lmvz-typography-body-sm, 400 clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem) / 1.5 Router);   color: var(--radio-helper-color);   margin-block-start: 2px; } .helper-text.sc-lmvz-radio:empty {   display: none; }  @media (hover: hover) {   .sc-lmvz-radio-h:hover .circle.sc-lmvz-radio {     border-color: var(--radio-border-color-hover);   }    .sc-lmvz-radio-h:hover {     background-color: var(--radio-wrapper-bg-hover);   } }  .sc-lmvz-radio-h:active {   background-color: var(--radio-wrapper-bg-active); }  [checked].sc-lmvz-radio-h .circle.sc-lmvz-radio {   border-color: var(--radio-border-color-checked); } [checked].sc-lmvz-radio-h label.sc-lmvz-radio {   color: var(--radio-label-color-checked); }  [error].sc-lmvz-radio-h .circle.sc-lmvz-radio {   border-color: var(--radio-border-color-error); } [error].sc-lmvz-radio-h .helper-text.sc-lmvz-radio {   color: var(--lmvz-semantic-color-status-on-danger, #a31419); }  [disabled].sc-lmvz-radio-h {   opacity: var(--lmvz-component-input-disabled-opacity, 40%);   pointer-events: none;   cursor: not-allowed; }  @media (forced-colors: active) {   .circle.sc-lmvz-radio {     forced-color-adjust: auto;     border-color: ButtonText;     background-color: Field;   }    [checked].sc-lmvz-radio-h .circle.sc-lmvz-radio {     border-color: Highlight;   }    .dot.sc-lmvz-radio {     background-color: ButtonText;   }    [checked].sc-lmvz-radio-h .dot.sc-lmvz-radio {     background-color: HighlightText;   } }`;
 
-const focusWithinCss$1 = () => `.sc-lmvz-radio-h:focus-within{outline:var(--lmvz-ds-outline, 1px solid #0e7ab4);outline-offset:var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem))}@media (forced-colors: active){.sc-lmvz-radio-h:focus-within{outline-color:Highlight;box-shadow:none}}`;
+const focusWithinCss$1 = () => `.sc-lmvz-radio-h:has(:focus-visible){outline:var(--lmvz-ds-outline, 1px solid #0e7ab4);outline-offset:var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem))}@media (forced-colors: active){.sc-lmvz-radio-h:has(:focus-visible){outline-color:Highlight;box-shadow:none}}`;
 
 let radioIdCounter = 0;
 class LmvzRadio extends ReactiveControllerHost {
@@ -11698,7 +14630,14 @@ class LmvzRadio extends ReactiveControllerHost {
     name;
     disabled = false;
     required = false;
-    error = false;
+    nativeError = false;
+    errorFromProp = false;
+    get error() {
+        return this.errorFromProp || this.nativeError;
+    }
+    set error(value) {
+        this.errorFromProp = value;
+    }
     helperText;
     form;
     autofocus = false;
@@ -11706,6 +14645,7 @@ class LmvzRadio extends ReactiveControllerHost {
     _handlingFormReset = false;
     handleCheckedChange(newVal, oldVal) {
         this.internals.setFormValue?.(newVal ? this.value : null);
+        this.updateValidity();
         if (!newVal && oldVal && !this._handlingNativeChange && !this._handlingFormReset) {
             this.lmvzChange.emit(false);
         }
@@ -11713,6 +14653,9 @@ class LmvzRadio extends ReactiveControllerHost {
             this.lmvzChange.emit(true);
         }
     }
+    handleRequiredChange() {
+        this.updateValidity();
+    }
     handleValueChange(newVal) {
         if (this.checked) {
             this.internals.setFormValue?.(newVal);
@@ -11734,6 +14677,9 @@ class LmvzRadio extends ReactiveControllerHost {
     async reportValidity() {
         return this.internals?.reportValidity() ?? true;
     }
+    async getValidationMessage() {
+        return this.internals?.validationMessage ?? '';
+    }
     constructor(hostRef) {
         super();
         registerInstance(this, hostRef);
@@ -11755,8 +14701,13 @@ class LmvzRadio extends ReactiveControllerHost {
     componentWillLoad() {
         this.initialChecked = this.checked;
         this.internals.setFormValue?.(this.checked ? this.value : null);
+        this.updateValidity();
         super.componentWillLoad();
     }
+    componentDidLoad() {
+        this.updateValidity();
+        super.componentDidLoad();
+    }
     formAssociatedCallback() {
         this.internals.setFormValue?.(this.checked ? this.value : null);
     }
@@ -11768,6 +14719,8 @@ class LmvzRadio extends ReactiveControllerHost {
         finally {
             this._handlingFormReset = false;
         }
+        this.updateValidity();
+        this.radioGroupController.refreshValidity();
     }
     formStateRestoreCallback(state) {
         if (typeof state !== 'string')
@@ -11780,6 +14733,20 @@ class LmvzRadio extends ReactiveControllerHost {
             this._handlingFormReset = false;
         }
     }
+    isAnyInGroupChecked() {
+        return this.radioGroupController.isAnyChecked();
+    }
+    updateValidity() {
+        if (this.required && !this.isAnyInGroupChecked()) {
+            this.internals.setValidity?.({ valueMissing: true }, 'Please select an option.', this.nativeInput);
+            return;
+        }
+        this.internals.setValidity?.({});
+        this.nativeError = false;
+    }
+    handleInvalid() {
+        this.nativeError = true;
+    }
     handleChange = (event) => {
         this._handlingNativeChange = true;
         try {
@@ -11822,14 +14789,20 @@ class LmvzRadio extends ReactiveControllerHost {
             return;
         this.radioGroupController.setFocused(target);
     }
+    retargetInnerClicks() {
+        this.nativeInput?.click();
+    }
     render() {
-        return (hAsync(Host, { key: 'c233b8f8e67016dd9a8622359bd91d3193735438' }, hAsync("input", { key: '6a0a028f4ae346b60f86109d33058f7a04f0f2f8', type: "radio", id: this.radioId, name: this.name ?? undefined, value: this.value, checked: this.checked, disabled: this.disabled, required: this.required, autoFocus: this.autofocus, "aria-invalid": this.error ? 'true' : undefined, "aria-describedby": this.helperId, ref: (el) => (this.nativeInput = el), onChange: this.handleChange }), hAsync("span", { key: 'f86096dd776236e07292dab77a37aeedffb8d8d4', class: "circle", "aria-hidden": "true" }, this.checked && hAsync("span", { key: '8e93beefee742af62775d4d5945df8d13adb739f', class: "dot" })), hAsync("span", { key: '19df96e6d015d0f74c96781ae49191a542a4f41d', class: "content" }, hAsync("label", { key: 'b678b54ca139191ff78d5f503b73ea407eeb0708', htmlFor: this.radioId }, this.label), hAsync("span", { key: '4a1e8a60594e959cb5549dd20b3d35a715ce1d99', "aria-live": "polite", class: "helper-text", id: this.helperId }, this.helperText))));
+        return (hAsync(Host, { key: 'f1fdc1167c4e59c2524e1e545c3382ca32853788' }, hAsync("input", { key: 'c1b711444475ed401766cc5827eeaec0c46b62cf', type: "radio", id: this.radioId, value: this.value, checked: this.checked, disabled: this.disabled, autoFocus: this.autofocus, "aria-required": this.required ? 'true' : 'false', "aria-invalid": this.error ? 'true' : undefined, "aria-describedby": this.helperId, ref: (el) => (this.nativeInput = el), onChange: this.handleChange }), hAsync("span", { key: 'b25e623269df05bdf8159e72da4df2e0bfb5d7bc', class: "circle", "aria-hidden": "true" }, this.checked && hAsync("span", { key: '93d12890c7ba0abe203c63953ea1115aee37d7a0', class: "dot" })), hAsync("span", { key: '44dcfdc4e7ee3820624b0d02a438139f45bb8733', class: "content" }, hAsync("label", { key: 'd0547cd5e79642b298da155c9937715224b52cae', htmlFor: this.radioId }, this.label), hAsync("span", { key: 'a9df5dd8a775a2f7422d5bac296869f88553e33f', onClick: this.retargetInnerClicks.bind(this), "aria-live": "polite", class: "helper-text", id: this.helperId }, this.helperText))));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
         "checked": [{
                 "handleCheckedChange": 0
             }],
+        "required": [{
+                "handleRequiredChange": 0
+            }],
         "value": [{
                 "handleValueChange": 0
             }],
@@ -11845,24 +14818,181 @@ class LmvzRadio extends ReactiveControllerHost {
             "label": [1],
             "checked": [1540],
             "value": [1],
-            "name": [1],
+            "name": [513],
             "disabled": [516],
             "required": [516],
-            "error": [516],
+            "error": [6660],
             "helperText": [1, "helper-text"],
             "form": [513],
             "autofocus": [4],
+            "nativeError": [32],
             "focusInput": [64],
             "checkValidity": [64],
-            "reportValidity": [64]
+            "reportValidity": [64],
+            "getValidationMessage": [64]
         },
-        "$listeners$": [[0, "keydown", "handleKeydown"]],
+        "$listeners$": [[0, "invalid", "handleInvalid"], [0, "keydown", "handleKeydown"]],
         "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["checked", "checked"], ["disabled", "disabled"], ["required", "required"], ["error", "error"], ["form", "form"]]
+        "$attrsToReflect$": [["checked", "checked"], ["name", "name"], ["disabled", "disabled"], ["required", "required"], ["error", "error"], ["form", "form"]]
     }; }
 }
 
-const lmvzSelectCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-select-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);       --lmvz-internal-select-floating-label-top-offset: 0.375rem;    padding-top: var(--lmvz-internal-select-floating-label-top-offset);    --lmvz-select-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-select-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --lmvz-select-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --lmvz-select-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --lmvz-select-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-select-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-label-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-select-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-xs-font-size, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   --lmvz-select-label-top-offset: calc(var(--lmvz-internal-select-floating-label-top-offset) * -1);   --lmvz-select-label-minimized-padding-x: 4px;   --lmvz-select-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%);   --lmvz-select-helper-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --lmvz-select-focus-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --lmvz-select-error-color: var(--lmvz-semantic-color-status-on-danger, #a31419); } .select-wrapper.sc-lmvz-select {   position: relative;   height: var(--lmvz-select-height); }  label.sc-lmvz-select {   position: absolute;   top: 50%;   left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-label-color);   line-height: normal;   white-space: nowrap;   pointer-events: none;   z-index: 2;   transform: translateY(-50%);   transform-origin: left top;   transition:     top 0.2s ease-out,     transform 0.2s ease-out,     opacity 0.2s ease-out,     padding 0.2s ease-out; } label.assistive-label.sc-lmvz-select {   opacity: 0;   padding: 0; } label.floating-label.sc-lmvz-select {   top: var(--lmvz-select-label-top-offset);   transform: translateY(0) scale(0.85);   left: calc(var(--lmvz-select-padding-x) - 2px);   background-color: var(--lmvz-select-bg);   padding: 0 var(--lmvz-select-label-minimized-padding-x);   opacity: 1;   font-weight: 500; } label.sc-lmvz-select > span[aria-hidden='true'].sc-lmvz-select, div[aria-hidden='true'].sc-lmvz-select > span.sc-lmvz-select:first-child > span[aria-hidden='true'].sc-lmvz-select {   color: var(--lmvz-select-error-color);   margin-left: 2px;   display: inline-block;   line-height: 0;   vertical-align: middle; }  div[aria-hidden].sc-lmvz-select {   display: flex;   align-items: center;   gap: var(--lmvz-select-gap);   height: 100%;   padding: 0 var(--lmvz-select-padding-x);   border-radius: var(--lmvz-select-radius);   background-color: var(--lmvz-select-bg);   border: var(--lmvz-select-border-width) solid var(--lmvz-select-border-color);   box-sizing: border-box;   cursor: pointer;   position: relative;   z-index: 1;   transition: border-color 0.15s ease; } .sc-lmvz-select-h:not([disabled] .select-wrapper.sc-lmvz-select:hover div[aria-hidden].sc-lmvz-select, [highlighted]).sc-lmvz-select-h .select-wrapper.sc-lmvz-select:hover div[aria-hidden].sc-lmvz-select {   border-color: var(--lmvz-select-border-color-hover); } [highlighted].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   border-color: var(--lmvz-semantic-color-border-active, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } [highlighted].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } [highlighted].sc-lmvz-select-h label.floating-label.sc-lmvz-select {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } .select-wrapper.sc-lmvz-select:focus-within div[aria-hidden].sc-lmvz-select {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   flex: 1 0 0;   font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   color: var(--lmvz-select-text-color);   overflow: hidden;   text-overflow: ellipsis;   white-space: nowrap; }  .sc-lmvz-select-h:not([highlighted]) .select-wrapper.has-value.sc-lmvz-select div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   color: var(--lmvz-semantic-color-int-on-secondary-active, #000000); } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:last-child {   flex-shrink: 0;   display: flex;   align-items: center;   justify-content: center; } div[aria-hidden].sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-2xs, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   height: var(--lmvz-component-icon-size-2xs, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   flex-shrink: 0; }  select.sc-lmvz-select {   appearance: none;   position: absolute;   inset: 0;   width: 100%;   height: 100%;   opacity: 0;   cursor: pointer;   z-index: 2;   border: none;   background: transparent;   margin: 0;   padding: 0; } [disabled].sc-lmvz-select-h .select-wrapper.sc-lmvz-select {   opacity: var(--lmvz-select-disabled-opacity);   pointer-events: none;   cursor: not-allowed; } [role='status'].sc-lmvz-select {   margin-top: 4px;   padding-left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-helper-color);   line-height: normal; } [size='small'].sc-lmvz-select-h {   --lmvz-select-height: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem));   --lmvz-select-padding-x: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-sm, clamp(0.38rem, 0.31rem + 0.26vw, 0.63rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-2xs-font-size, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem)); } [size='small'].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='small'].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-4xs, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem));   height: var(--lmvz-component-icon-size-4xs, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem)); } [size='large'].sc-lmvz-select-h {   --lmvz-select-height: var(--lmvz-component-input-size-lg, clamp(2.75rem, 2.69rem + 0.26vw, 3rem));   --lmvz-select-padding-x: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='large'].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   font-size: var(--lmvz-component-body-lg-font-size, clamp(1rem, 0.97rem + 0.13vw, 1.13rem)); } [size='large'].sc-lmvz-select-h div[aria-hidden].sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   height: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); }`;
+const defaultConfig = {
+    wrap: true,
+    typeaheadTimeoutMs: 500,
+};
+class ListboxController {
+    options = [];
+    _activeId;
+    _selectedId;
+    config;
+    typeaheadBuffer = '';
+    typeaheadTimer;
+    constructor(config = {}) {
+        this.config = { ...defaultConfig, ...config };
+    }
+    hostDisconnected() {
+        this.clearTypeaheadTimer();
+    }
+    get activeId() {
+        return this._activeId;
+    }
+    get activeDescendantId() {
+        return this._activeId;
+    }
+    get selectedId() {
+        return this._selectedId;
+    }
+    setOptions(options) {
+        this.options = options;
+        if (this._activeId && this.findEnabledIndex(this._activeId) !== -1)
+            return;
+        const fallback = (this._selectedId && this.findEnabledIndex(this._selectedId) !== -1 ? this._selectedId : undefined) ?? this.firstEnabledOption()?.id;
+        this.setActiveId(fallback);
+    }
+    setActiveId(id) {
+        if (id !== undefined && !this.isEnabledId(id))
+            return;
+        if (id === this._activeId)
+            return;
+        this._activeId = id;
+        this.config.onActiveChange?.(id);
+    }
+    setSelectedId(id) {
+        this._selectedId = id;
+    }
+    selectOption(id) {
+        if (!this.isEnabledId(id))
+            return;
+        this._selectedId = id;
+        this.config.onSelect?.(id);
+    }
+    selectActive() {
+        if (this._activeId)
+            this.selectOption(this._activeId);
+    }
+    handleKeydown(event) {
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.moveActive('next');
+                return true;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.moveActive('previous');
+                return true;
+            case 'Home':
+                event.preventDefault();
+                this.setActiveId(this.firstEnabledOption()?.id);
+                return true;
+            case 'End':
+                event.preventDefault();
+                this.setActiveId(this.lastEnabledOption()?.id);
+                return true;
+            case 'Enter':
+            case ' ':
+                event.preventDefault();
+                this.selectActive();
+                return true;
+            case 'Escape':
+                event.preventDefault();
+                this.config.onClose?.();
+                return true;
+            default:
+                return this.handleTypeahead(event);
+        }
+    }
+    clearTypeahead() {
+        this.typeaheadBuffer = '';
+        this.clearTypeaheadTimer();
+    }
+    moveActive(direction) {
+        const enabledOptions = this.enabledOptions();
+        if (!enabledOptions.length)
+            return;
+        const currentIndex = this._activeId ? enabledOptions.findIndex((option) => option.id === this._activeId) : -1;
+        if (currentIndex === -1) {
+            this.setActiveId((direction === 'next' ? enabledOptions[0] : enabledOptions[enabledOptions.length - 1])?.id);
+            return;
+        }
+        const step = direction === 'next' ? 1 : -1;
+        const rawIndex = currentIndex + step;
+        if (rawIndex < 0 || rawIndex >= enabledOptions.length) {
+            if (!this.config.wrap)
+                return;
+            const wrappedIndex = (rawIndex + enabledOptions.length) % enabledOptions.length;
+            this.setActiveId(enabledOptions[wrappedIndex]?.id);
+            return;
+        }
+        this.setActiveId(enabledOptions[rawIndex]?.id);
+    }
+    handleTypeahead(event) {
+        if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey)
+            return false;
+        event.preventDefault();
+        this.typeaheadBuffer += event.key.toLowerCase();
+        this.restartTypeaheadTimer();
+        const enabledOptions = this.enabledOptions();
+        if (!enabledOptions.length)
+            return true;
+        const currentIndex = this._activeId ? enabledOptions.findIndex((option) => option.id === this._activeId) : -1;
+        const orderedFromCurrent = [...enabledOptions.slice(currentIndex + 1), ...enabledOptions.slice(0, currentIndex + 1)];
+        const match = orderedFromCurrent.find((option) => option.label.toLowerCase().startsWith(this.typeaheadBuffer));
+        if (match)
+            this.setActiveId(match.id);
+        return true;
+    }
+    restartTypeaheadTimer() {
+        this.clearTypeaheadTimer();
+        this.typeaheadTimer = setTimeout(() => {
+            this.typeaheadBuffer = '';
+        }, this.config.typeaheadTimeoutMs);
+    }
+    clearTypeaheadTimer() {
+        if (this.typeaheadTimer !== undefined) {
+            clearTimeout(this.typeaheadTimer);
+            this.typeaheadTimer = undefined;
+        }
+    }
+    enabledOptions() {
+        return this.options.filter((option) => !option.disabled);
+    }
+    firstEnabledOption() {
+        return this.enabledOptions()[0];
+    }
+    lastEnabledOption() {
+        const enabledOptions = this.enabledOptions();
+        return enabledOptions[enabledOptions.length - 1];
+    }
+    isEnabledId(id) {
+        return this.findEnabledIndex(id) !== -1;
+    }
+    findEnabledIndex(id) {
+        return this.enabledOptions().findIndex((option) => option.id === id);
+    }
+}
+
+const lmvzSelectCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-select-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);       --lmvz-internal-select-floating-label-top-offset: 0.375rem;   --lmvz-select-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-select-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --lmvz-select-border-color: var(--lmvz-semantic-color-border-alternate, #c7c7c7);   --lmvz-select-border-color-hover: var(--lmvz-semantic-color-border-hover, #a1a1a1);   --lmvz-select-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-select-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-label-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-padding-x: var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-select-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-xs-font-size, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   --lmvz-select-label-top-offset: calc(var(--lmvz-internal-select-floating-label-top-offset) * -1);   --lmvz-select-label-minimized-padding-x: 4px;   --lmvz-select-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%);   --lmvz-select-helper-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   --lmvz-select-focus-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --lmvz-select-error-color: var(--lmvz-semantic-color-status-on-danger, #a31419);    padding-top: var(--lmvz-internal-select-floating-label-top-offset); } .select-wrapper.sc-lmvz-select {   position: relative;   height: var(--lmvz-select-height); }  label.sc-lmvz-select {   position: absolute;   top: 50%;   left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-label-color);   line-height: normal;   white-space: nowrap;   pointer-events: none;   z-index: 2;   transform: translateY(-50%);   transform-origin: left top;   transition:     top 0.2s ease-out,     transform 0.2s ease-out,     opacity 0.2s ease-out,     padding 0.2s ease-out; } label.assistive-label.sc-lmvz-select {   opacity: 0;   padding: 0; } label.floating-label.sc-lmvz-select {   top: var(--lmvz-select-label-top-offset);   transform: translateY(0) scale(0.85);   left: calc(var(--lmvz-select-padding-x) - 2px);   background-color: var(--lmvz-select-bg);   padding: 0 var(--lmvz-select-label-minimized-padding-x);   opacity: 1;   font-weight: 500; } label.sc-lmvz-select > span[aria-hidden='true'].sc-lmvz-select, .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child > span[aria-hidden='true'].sc-lmvz-select {   color: var(--lmvz-select-error-color);   margin-left: 2px;   display: inline-block;   line-height: 0;   vertical-align: middle; }  .select-trigger.sc-lmvz-select {   display: flex;   align-items: center;   gap: var(--lmvz-select-gap);   height: 100%;   width: 100%;   padding: 0 var(--lmvz-select-padding-x);   border-radius: var(--lmvz-select-radius);   background-color: var(--lmvz-select-bg);   border: var(--lmvz-select-border-width) solid var(--lmvz-select-border-color);   box-sizing: border-box;   cursor: pointer;   position: relative;   z-index: 1;   transition: border-color 0.15s ease; } .sc-lmvz-select-h:not([disabled] .select-wrapper.sc-lmvz-select:hover .select-trigger.sc-lmvz-select, [highlighted].sc-lmvz-select-h .select-wrapper.sc-lmvz-select:hover .select-trigger.sc-lmvz-select, [error]).sc-lmvz-select-h .select-wrapper.sc-lmvz-select:hover .select-trigger.sc-lmvz-select {   border-color: var(--lmvz-select-border-color-hover); } [error].sc-lmvz-select-h .select-trigger.sc-lmvz-select {   border-color: var(--lmvz-select-error-color); } [highlighted].sc-lmvz-select-h .select-trigger.sc-lmvz-select {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   border-color: var(--lmvz-semantic-color-border-active, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } [highlighted].sc-lmvz-select-h .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child {   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } [highlighted].sc-lmvz-select-h label.floating-label.sc-lmvz-select {   background-color: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } .sc-lmvz-select-h:has(:focus-visible) .select-trigger.sc-lmvz-select {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); } .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child {   flex: 1 0 0;   font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   color: var(--lmvz-select-text-color);   overflow: hidden;   text-overflow: ellipsis;   white-space: nowrap;   text-align: left; }  .sc-lmvz-select-h:not([highlighted]) .select-wrapper.has-value.sc-lmvz-select .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child {   color: var(--lmvz-semantic-color-int-on-secondary-active, #000000); } .select-trigger.sc-lmvz-select > span.sc-lmvz-select:last-child {   flex-shrink: 0;   display: flex;   align-items: center;   justify-content: center; } .select-trigger.sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-2xs, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   height: var(--lmvz-component-icon-size-2xs, clamp(0.63rem, 0.59rem + 0.13vw, 0.75rem));   flex-shrink: 0; }  .lmvz-select-native-options.sc-lmvz-select {   display: none; } [disabled].sc-lmvz-select-h .select-wrapper.sc-lmvz-select {   opacity: var(--lmvz-select-disabled-opacity);   pointer-events: none;   cursor: not-allowed; } [role='status'].sc-lmvz-select {   padding-top: var(--lmvz-dimension-8-6, clamp(0.38rem, 0.34rem + 0.13vw, 0.5rem));   padding-left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-helper-color);   line-height: normal; } [role='alert'].sc-lmvz-select {   padding-top: var(--lmvz-dimension-8-6, clamp(0.38rem, 0.34rem + 0.13vw, 0.5rem));   padding-left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   color: var(--lmvz-select-error-color);   line-height: normal; } [size='small'].sc-lmvz-select-h {   --lmvz-select-height: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem));   --lmvz-select-padding-x: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-sm, clamp(0.38rem, 0.31rem + 0.26vw, 0.63rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-2xs-font-size, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem)); } [size='small'].sc-lmvz-select-h .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child {   font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='small'].sc-lmvz-select-h .select-trigger.sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-4xs, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem));   height: var(--lmvz-component-icon-size-4xs, clamp(0.5rem, 0.47rem + 0.13vw, 0.63rem)); } [size='large'].sc-lmvz-select-h {   --lmvz-select-height: var(--lmvz-component-input-size-lg, clamp(2.75rem, 2.69rem + 0.26vw, 3rem));   --lmvz-select-padding-x: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --lmvz-select-gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --lmvz-select-label-font-size: var(--lmvz-component-body-sm-font-size, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); } [size='large'].sc-lmvz-select-h .select-trigger.sc-lmvz-select > span.sc-lmvz-select:first-child {   font-size: var(--lmvz-component-body-lg-font-size, clamp(1rem, 0.97rem + 0.13vw, 1.13rem)); } [size='large'].sc-lmvz-select-h .select-trigger.sc-lmvz-select svg.sc-lmvz-select {   width: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   height: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); }  .lmvz-select-option.sc-lmvz-select {   --lmvz-select-option-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-select-option-color: var(--lmvz-semantic-color-int-on-tertiary, #000000);    display: flex;   align-items: center;   gap: var(--lmvz-select-gap);   padding: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   border-radius: var(--lmvz-semantic-border-radius-md, 6px);   background-color: var(--lmvz-select-option-background);   color: var(--lmvz-select-option-color);   cursor: pointer;   font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   transition:     background-color 0.15s ease,     color 0.15s ease; } .lmvz-select-option.sc-lmvz-select:not([aria-disabled='true']):hover {   --lmvz-select-option-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --lmvz-select-option-color: var(--lmvz-semantic-color-int-on-tertiary-hover, #000000); } .lmvz-select-option.sc-lmvz-select:not([aria-disabled='true']):active {   --lmvz-select-option-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0);   --lmvz-select-option-color: var(--lmvz-semantic-color-int-on-tertiary-active, #000000); } .lmvz-select-option.sc-lmvz-select:focus-visible {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem));   position: relative;   z-index: 1; } .lmvz-select-option[data-active='true'].sc-lmvz-select:not([aria-disabled='true']) {   --lmvz-select-option-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --lmvz-select-option-color: var(--lmvz-semantic-color-int-on-tertiary-hover, #000000); } .lmvz-select-option[aria-selected='true'].sc-lmvz-select {   --lmvz-select-option-background: var(--lmvz-semantic-color-status-active-alternate, #0f8acc);   --lmvz-select-option-color: var(--lmvz-semantic-color-status-on-active-alternate, #ffffff); } .lmvz-select-option[aria-disabled='true'].sc-lmvz-select {   cursor: not-allowed;   pointer-events: none;   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }`;
 
 let selectIdCounter = 0;
 class LmvzSelect extends ReactiveControllerHost {
@@ -11870,79 +15000,343 @@ class LmvzSelect extends ReactiveControllerHost {
     get validationEl() {
         return this.el;
     }
+    internals;
     selectId = `lmvz-select-${selectIdCounter++}`;
-    nativeSelectEl;
+    triggerId = `${this.selectId}-trigger`;
+    popoverId = `${this.selectId}-listbox`;
+    triggerEl;
+    optionsSourceEl;
+    optionsMutationObserver;
+    initialValue;
+    initialValueCaptured = false;
+    flatOptions = [];
+    optionsById = new Map();
+    listboxController = new ListboxController({
+        onActiveChange: (id) => {
+            this.activeId = id;
+        },
+        onSelect: (id) => this.handleOptionSelect(id),
+        onClose: () => this.closePopover(),
+    });
+    get helperId() {
+        return this.helperText ? `${this.selectId}-helper` : undefined;
+    }
+    get showErrorMessage() {
+        return this.error && Boolean(this.errorMessage);
+    }
+    get errorId() {
+        return `${this.selectId}-error`;
+    }
+    get describedBy() {
+        const ids = [];
+        if (this.helperId)
+            ids.push(this.helperId);
+        if (this.showErrorMessage)
+            ids.push(this.errorId);
+        return ids.length > 0 ? ids.join(' ') : undefined;
+    }
     constructor(hostRef) {
         super();
         registerInstance(this, hostRef);
         this.lmvzChange = createEvent(this, "lmvzChange", 7);
+        if (hostRef.$hostElement$["s-ei"]) {
+            this.internals = hostRef.$hostElement$["s-ei"];
+        }
+        else {
+            this.internals = hostRef.$hostElement$.attachInternals();
+            hostRef.$hostElement$["s-ei"] = this.internals;
+        }
         this.addController(new AriaValidationController(this));
+        this.addController(this.listboxController);
     }
     lmvzChange;
     value;
     label;
     helperText;
+    nativeError = false;
+    errorFromProp = false;
+    get error() {
+        return this.errorFromProp || this.nativeError;
+    }
+    set error(value) {
+        this.errorFromProp = value;
+    }
+    errorMessage;
     disabled = false;
     required = false;
     name;
     size = 'default';
     highlighted = false;
     selectedLabel = '';
+    selectedId;
+    activeId;
+    isOpen = false;
+    optionGroups = [];
     get hasValue() {
         return Boolean(this.value);
     }
+    componentWillLoad() {
+        this.updateValidity();
+        super.componentWillLoad();
+    }
     componentDidLoad() {
-        this.syncSelectedLabel();
+        this.handleSlotChange();
+        this.observeSlottedOptionMutations();
+        this.updateValidity();
         super.componentDidLoad();
     }
+    disconnectedCallback() {
+        this.optionsMutationObserver?.disconnect();
+        super.disconnectedCallback();
+    }
+    observeSlottedOptionMutations() {
+        if (typeof MutationObserver === 'undefined')
+            return;
+        this.optionsMutationObserver?.disconnect();
+        this.optionsMutationObserver = new MutationObserver(this.handleSlotChange);
+        this.optionsMutationObserver.observe(this.el, {
+            attributes: true,
+            attributeFilter: ['disabled', 'selected', 'value', 'label'],
+            characterData: true,
+            childList: true,
+            subtree: true,
+        });
+    }
+    async focusTrigger() {
+        this.triggerEl?.focus();
+    }
+    async blurTrigger() {
+        this.triggerEl?.blur();
+    }
+    async checkValidity() {
+        return this.internals.checkValidity?.() ?? true;
+    }
+    async reportValidity() {
+        return this.internals.reportValidity?.() ?? true;
+    }
+    async getValidationMessage() {
+        return this.internals.validationMessage ?? '';
+    }
+    formAssociatedCallback(form) {
+        if (!form)
+            return;
+        this.internals.setFormValue?.(this.value ?? '');
+    }
+    formResetCallback() {
+        this.internals.setValidity?.({});
+        this.value = this.initialValue;
+        this.updateValidity();
+    }
+    formStateRestoreCallback(state) {
+        this.value = state;
+    }
     handleValueChange(newValue) {
-        if (this.nativeSelectEl && this.nativeSelectEl.value !== (newValue ?? '')) {
-            this.nativeSelectEl.value = newValue ?? '';
+        this.applySelectionFromValue();
+        if (this.selectedId && !this.isOpen) {
+            this.listboxController.setActiveId(this.selectedId);
         }
-        this.syncSelectedLabel();
+        this.internals.setFormValue?.(newValue ?? '');
+        this.updateValidity();
     }
-    syncSelectedLabel() {
-        if (!this.nativeSelectEl)
+    handleRequiredChange() {
+        this.updateValidity();
+    }
+    handleDisabledChange(disabled) {
+        if (!disabled)
             return;
-        const idx = this.nativeSelectEl.selectedIndex;
-        this.selectedLabel = idx >= 0 ? (this.nativeSelectEl.options[idx]?.text ?? '') : '';
+        this.closePopover();
+        this.triggerEl?.blur();
     }
-    handleChange = (event) => {
-        const select = event.target;
-        this.value = select.value;
-        this.syncSelectedLabel();
-        this.lmvzChange.emit(select.value);
+    handleSlotChange = () => {
+        const container = this.optionsSourceEl;
+        if (!container)
+            return;
+        const { flat, groups } = parseOptionElements(container, this.selectId);
+        this.flatOptions = flat;
+        this.optionsById = new Map(flat.map((option) => [option.id, option]));
+        this.optionGroups = groups;
+        if (!this.value) {
+            const preselected = flat.find((option) => option.selected && !option.disabled);
+            if (preselected) {
+                this.value = preselected.value;
+            }
+        }
+        this.applySelectionFromValue();
+        this.listboxController.setOptions(flat.map(({ id, label, disabled }) => ({ id, label, disabled })));
+        if (!this.initialValueCaptured) {
+            this.initialValue = this.value;
+            this.initialValueCaptured = true;
+        }
+    };
+    applySelectionFromValue() {
+        const match = this.value ? this.flatOptions.find((option) => option.value === this.value) : undefined;
+        this.selectedId = match?.id;
+        this.selectedLabel = match?.label ?? '';
+        this.listboxController.setSelectedId(match?.id);
+    }
+    updateValidity() {
+        if (this.required && !this.value) {
+            this.internals.setValidity?.({ valueMissing: true }, 'Please select a value.', this.triggerEl);
+            return;
+        }
+        this.internals.setValidity?.({});
+        this.nativeError = false;
+    }
+    handleInvalid() {
+        this.nativeError = true;
+    }
+    handleOptionSelect(id) {
+        const option = this.optionsById.get(id);
+        if (!option)
+            return;
+        const isNewValue = option.value !== this.value;
+        this.value = option.value;
+        if (isNewValue) {
+            this.lmvzChange.emit(option.value);
+        }
+        this.closePopover();
+    }
+    handleOptionClick = (option) => {
+        if (option.disabled || this.disabled)
+            return;
+        this.listboxController.selectOption(option.id);
+    };
+    handleLabelClick = () => {
+        if (this.disabled)
+            return;
+        this.triggerEl?.focus();
+        this.openPopover();
+    };
+    handleTriggerClick = () => {
+        if (this.disabled)
+            return;
+        if (this.isOpen) {
+            this.closePopover();
+        }
+        else {
+            this.openPopover();
+        }
+    };
+    handleTriggerKeydown = (event) => {
+        if (this.disabled)
+            return;
+        if (!this.isOpen) {
+            if (event.key === 'ArrowDown' || event.key === 'ArrowUp' || event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                this.openPopover();
+            }
+            return;
+        }
+        this.listboxController.handleKeydown(event);
+    };
+    handleTriggerBlur = () => {
+        this.closePopover();
     };
+    handlePopoverClose = () => {
+        this.isOpen = false;
+        this.listboxController.clearTypeahead();
+    };
+    openPopover() {
+        if (this.isOpen || this.disabled)
+            return;
+        this.isOpen = true;
+    }
+    closePopover() {
+        if (!this.isOpen)
+            return;
+        this.isOpen = false;
+        this.listboxController.clearTypeahead();
+    }
+    renderOptionGroups() {
+        return this.optionGroups.map((group, groupIndex) => group.label ? (hAsync("div", { role: "group", "aria-label": group.label, key: `lmvz-select-group-${groupIndex}` }, group.options.map((option) => this.renderOption(option)))) : (group.options.map((option) => this.renderOption(option))));
+    }
+    renderOption(option) {
+        return (hAsync("div", { id: option.id, key: option.id, role: "option", class: "lmvz-select-option", "aria-selected": option.id === this.selectedId ? 'true' : 'false', "aria-disabled": option.disabled ? 'true' : undefined, "data-active": option.id === this.activeId ? 'true' : undefined, onMouseDown: (event) => event.preventDefault(), onClick: () => this.handleOptionClick(option) }, option.label));
+    }
     render() {
         const hasValue = this.hasValue;
         const shouldShowLabel = hasValue;
-        return (hAsync(Host, { key: 'f1180d4a5f1c30414b06c19314eb75630aa181f7', "data-highlighted": String(this.highlighted) }, hAsync("div", { key: '01088c7f3315faab1fb23c99cf8b30f7d59abfc6', class: hasValue ? 'select-wrapper has-value' : 'select-wrapper' }, hAsync("label", { key: '34d23292b6b65fac000f822e1e2839e28b1bfee9', htmlFor: this.selectId, class: shouldShowLabel ? 'floating-label' : 'assistive-label' }, this.label, this.required && shouldShowLabel && hAsync("span", { key: 'ba171cdd9b53f8fa7b7fcb2c39a0b4aa69940b95', "aria-hidden": "true" }, " *")), hAsync("div", { key: '798a6ef187b4aaaa45ecb3d6f94c30e7facb7a38', "aria-hidden": "true" }, hAsync("span", { key: '33ea2169d94f4f8cf6263ed0c3bd6a9e593207a4' }, hasValue ? this.selectedLabel : this.label, this.required && !hasValue && hAsync("span", { key: '0ea2d4987587a1a42dfd037dcefeed3f1b3356ef', "aria-hidden": "true" }, " *")), hAsync("span", { key: '7bd24b3921cc5cd261f563476a79d61a288d60bb' }, hAsync("svg", { key: '9887853724abada1fe36f7225db7903ee6e4040d', width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true" }, hAsync("path", { key: 'b55a82230d46944ca3bd46f00f8c59b1a75ab8b8', d: "M20.3334 8.66663L12.0001 17L3.66675 8.66663", stroke: "currentColor", "stroke-width": "1.75", "stroke-linecap": "round", "stroke-linejoin": "round" })))), hAsync("select", { key: 'd786f49b4522baf4c803ed3046b3606f29d6dae1', id: this.selectId, ref: (el) => (this.nativeSelectEl = el), name: this.name, disabled: this.disabled, required: this.required, "aria-label": this.label, onChange: this.handleChange }, !hasValue && hAsync("option", { key: '5ffa7ffb7cd79c28a8bd212cc4d123dceb77aad4', value: "", disabled: true, selected: true, hidden: true }), hAsync("slot", { key: '8a4141ead35cfd07c14d869715397d12ea8b64d7' }))), this.helperText && hAsync("div", { key: 'dc5ccd28b0a903f6ed674d994e302caed1d9e9bb', role: "status" }, this.helperText)));
+        return (hAsync(Host, { key: '0bcc303a802db20a6be6558b8add53d0fa398493', "data-highlighted": String(this.highlighted) }, hAsync("div", { key: 'e248f8277b4786b34dfd064cb9c7b70302cf018a', class: hasValue ? 'select-wrapper has-value' : 'select-wrapper' }, hAsync("label", { key: '1c97c830d5782cadad98fb895d70c438031d3457', htmlFor: this.triggerId, class: shouldShowLabel ? 'floating-label' : 'assistive-label', onMouseDown: (event) => event.preventDefault(), onClick: this.handleLabelClick }, this.label, this.required && shouldShowLabel && hAsync("span", { key: '16157962846bffc111f5c672852f7b23e9ed2b73', "aria-hidden": "true" }, " *")), hAsync("div", { key: 'bc5e3e6b335723cfd9872ff955a1e8d664d4eeb8', id: this.triggerId, ref: (el) => (this.triggerEl = el), class: "select-trigger", role: "combobox", tabIndex: this.disabled ? -1 : 0, "aria-haspopup": "listbox", "aria-expanded": String(this.isOpen), "aria-controls": this.popoverId, "aria-activedescendant": this.isOpen ? this.activeId : undefined, "aria-label": hasValue ? `${this.label}, ${this.selectedLabel}` : this.label, "aria-disabled": this.disabled ? 'true' : undefined, "aria-required": this.required ? 'true' : 'false', "aria-invalid": this.error ? 'true' : 'false', "aria-errormessage": this.showErrorMessage ? this.errorId : undefined, "aria-describedby": this.describedBy, onClick: this.handleTriggerClick, onKeyDown: this.handleTriggerKeydown, onBlur: this.handleTriggerBlur }, hAsync("span", { key: '620c6108f679c8e5563c0e21d7b89d71434c01a2' }, hasValue ? this.selectedLabel : this.label, this.required && !hasValue && hAsync("span", { key: 'a2183941c7843bae3e9989f8e8b26be28fbbf6d7', "aria-hidden": "true" }, " *")), hAsync("span", { key: 'b57e14bda44dc0de5a35623a5cb203b7f570c802', "aria-hidden": "true" }, hAsync("svg", { key: '71ac319e398f07f7e65fe1f73f6d2a7c08b631a8', width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg" }, hAsync("path", { key: '80b4a978471251ee8d2cce2d74a48fad750db125', d: "M20.3334 8.66663L12.0001 17L3.66675 8.66663", stroke: "currentColor", "stroke-width": "1.75", "stroke-linecap": "round", "stroke-linejoin": "round" })))), hAsync("lmvz-popover", { key: '15528c9a3f1404c385f4eb865cf78ef5891dcb32', id: this.popoverId, anchor: this.triggerId, open: this.isOpen, containerRole: "listbox", autoFocus: false, label: this.label, onLmvzClose: this.handlePopoverClose, size: "sm" }, this.renderOptionGroups()), hAsync("div", { key: 'f1b833973497e6dfd2013522e067382c73baa7a1', class: "lmvz-select-native-options", hidden: true, "aria-hidden": "true", ref: (el) => (this.optionsSourceEl = el) }, hAsync("slot", { key: '670bf62c50cbdd965342279b99e303614771ffa1', onSlotchange: this.handleSlotChange }))), this.helperText && (hAsync("div", { key: '849e35da09bff25896b08f275c265baa0ee12960', id: this.helperId, role: "status" }, this.helperText)), this.showErrorMessage && (hAsync("div", { key: 'd01c2dca8767aa815d08d895f308c42150cc3263', id: this.errorId, role: "alert" }, this.errorMessage))));
     }
+    static get formAssociated() { return true; }
     static get watchers() { return {
         "value": [{
                 "handleValueChange": 0
+            }],
+        "required": [{
+                "handleRequiredChange": 0
+            }],
+        "disabled": [{
+                "handleDisabledChange": 0
             }]
     }; }
     static get style() { return lmvzSelectCss(); }
     static get cmpMeta() { return {
-        "$flags$": 774,
+        "$flags$": 838,
         "$tagName$": "lmvz-select",
         "$members$": {
             "value": [1025],
             "label": [1],
             "helperText": [1, "helper-text"],
+            "error": [6660],
+            "errorMessage": [1, "error-message"],
             "disabled": [516],
             "required": [516],
-            "name": [1],
+            "name": [513],
             "size": [513],
             "highlighted": [516],
-            "selectedLabel": [32]
+            "nativeError": [32],
+            "selectedLabel": [32],
+            "selectedId": [32],
+            "activeId": [32],
+            "isOpen": [32],
+            "optionGroups": [32],
+            "focusTrigger": [64],
+            "blurTrigger": [64],
+            "checkValidity": [64],
+            "reportValidity": [64],
+            "getValidationMessage": [64]
         },
-        "$listeners$": undefined,
+        "$listeners$": [[0, "invalid", "handleInvalid"]],
         "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["disabled", "disabled"], ["required", "required"], ["size", "size"], ["highlighted", "highlighted"]]
+        "$attrsToReflect$": [["error", "error"], ["disabled", "disabled"], ["required", "required"], ["name", "name"], ["size", "size"], ["highlighted", "highlighted"]]
     }; }
 }
+function parseOptionElements(container, idPrefix) {
+    const flat = [];
+    const groups = [];
+    let looseGroup;
+    let optionIndex = 0;
+    const toOptionData = (optionEl, disabledOverride = false) => {
+        const option = optionEl;
+        const data = {
+            id: `${idPrefix}-option-${optionIndex++}`,
+            value: option.value,
+            label: (option.textContent ?? '').trim(),
+            disabled: disabledOverride || option.disabled,
+            selected: option.selected,
+        };
+        flat.push(data);
+        return data;
+    };
+    Array.from(container.children).forEach((child) => {
+        if (child.tagName === 'OPTGROUP') {
+            looseGroup = undefined;
+            const optgroup = child;
+            const options = Array.from(optgroup.querySelectorAll('option')).map((option) => toOptionData(option, optgroup.disabled));
+            groups.push({ label: optgroup.label || undefined, options });
+            return;
+        }
+        if (child.tagName === 'OPTION') {
+            if (!looseGroup) {
+                looseGroup = { label: undefined, options: [] };
+                groups.push(looseGroup);
+            }
+            looseGroup.options.push(toOptionData(child));
+        }
+    });
+    return { flat, groups };
+}
 
 const alertSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzM0Nl8zODApIj4KPHBhdGggZD0iTTEyIDUuMjVWMTMuMTI1TTIyLjUgMTJDMjIuNSAxNy43OTkgMTcuNzk5IDIyLjUgMTIgMjIuNUM2LjIwMTAxIDIyLjUgMS41IDE3Ljc5OSAxLjUgMTJDMS41IDYuMjAxMDEgNi4yMDEwMSAxLjUgMTIgMS41QzE3Ljc5OSAxLjUgMjIuNSA2LjIwMTAxIDIyLjUgMTJaTTEzLjEyNSAxNi44NzVDMTMuMTI1IDE3LjQ5NjMgMTIuNjIxMyAxOCAxMiAxOEMxMS4zNzg3IDE4IDEwLjg3NSAxNy40OTYzIDEwLjg3NSAxNi44NzVDMTAuODc1IDE2LjI1MzcgMTEuMzc4NyAxNS43NSAxMiAxNS43NUMxMi42MjEzIDE1Ljc1IDEzLjEyNSAxNi4yNTM3IDEzLjEyNSAxNi44NzVaIiBzdHJva2U9ImJsYWNrIiBzdHJva2Utd2lkdGg9IjEuNzUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzM0Nl8zODAiPgo8cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIGZpbGw9IndoaXRlIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg==';
 
@@ -12008,7 +15402,7 @@ class LmvzSnackbar {
         this.el.dispatchEvent(new CustomEvent('lmvzAction', { bubbles: false, composed: false }));
     };
     render() {
-        return (hAsync(Host, { key: '6c2898f187ed9b456dd0c13294eb466270b116cb', class: this.animationClass }, hAsync("lmvz-icon", { key: '9b4903f0e2099d44f0ed1773ed23f948b894f603', icon: STATUS_SVG[this.status], size: "md", weight: "bold" }), hAsync("span", { key: '38163523ce0bba29dbe387e5c808ae9f5f2c2c55', class: "message" }, this.message), this.actionLabel && (hAsync("lmvz-button", { key: 'bf5eb3e5075dec7c10f95a46db207ccb3181c88b', variant: "tertiary", scale: "small", onLmvzActivation: this.handleActionClick }, this.actionLabel))));
+        return (hAsync(Host, { key: 'f58c7657bf5511c72930dfc54ace4af1ff7f3554', class: this.animationClass }, hAsync("lmvz-icon", { key: '8632b42b9b246bf58480fb17ca336ce5f0883845', icon: STATUS_SVG[this.status], size: "md", weight: "bold" }), hAsync("span", { key: '4ca56d2cdf29415c6d21cc50399dc28aebb8de99', class: "message" }, this.message), this.actionLabel && (hAsync("lmvz-button", { key: 'd09043056b968421143aa180f464effcd7b781fe', variant: "tertiary", scale: "small", onLmvzActivation: this.handleActionClick }, this.actionLabel))));
     }
     static get watchers() { return {
         "status": [{
@@ -12045,7 +15439,7 @@ class LmvzSpinner {
     ariaLabel;
     render() {
         const hasLabel = !!this.ariaLabel?.trim();
-        return (hAsync(Host, { key: '75f8aabfe2eae72d29c5f0aa0663d0c37286ab78', role: hasLabel ? 'status' : undefined, "aria-label": hasLabel ? this.ariaLabel : undefined, "aria-hidden": hasLabel ? undefined : 'true' }, hAsync("svg", { key: 'aadf9daaa1f363752e08eed3136fc8a8f15d3bdf', part: "indicator", viewBox: "0 0 16 16", "aria-hidden": "true" }, hAsync("circle", { key: 'e658f4be70b5bd03b3828071cbce977576afa3c8', pathLength: "100", cx: "8", cy: "8", r: "6" }))));
+        return (hAsync(Host, { key: 'cf60fcf652f377a66596cc51138bb73f7465a4e7', role: hasLabel ? 'status' : undefined, "aria-label": hasLabel ? this.ariaLabel : undefined, "aria-hidden": hasLabel ? undefined : 'true' }, hAsync("svg", { key: '121ab46a591242fbc0f1c3540e8f2a7b72c9582a', part: "indicator", viewBox: "0 0 16 16", "aria-hidden": "true" }, hAsync("circle", { key: 'fe649394c9bd6e7a06113e9a50b595bb890a6fac', pathLength: "100", cx: "8", cy: "8", r: "6" }))));
     }
     static get style() { return lmvzSpinnerCss(); }
     static get cmpMeta() { return {
@@ -12081,7 +15475,7 @@ class LmvzTab {
         this.el.dispatchEvent(new CustomEvent('lmvzTabReady', { bubbles: true, composed: false }));
     }
     render() {
-        return (hAsync(Host, { key: '6bb908c4956e84cd344fc8e81b400d33bb2dce98' }, hAsync("button", { key: 'fbc5b650c9bfb5653d17f9a66a14ffbf0fe87f83', part: "button", role: "tab", disabled: this.disabled, "aria-selected": String(this.selected), "aria-disabled": this.disabled ? 'true' : undefined, tabIndex: 0 }, hAsync("slot", { key: 'a16da4d11ecca9db3d03da3b0076b698295ead1f', name: "media", ref: (el) => (this.mediaSlotEl = el), onSlotchange: this.handleMediaSlotChange }), hAsync("span", { key: 'e9e83fd4aa556716af3c7b7e52e1e1d8a5a33061', class: "label" }, hAsync("slot", { key: 'a4c0378e62d67d7bcc772ff6a77ae1a86f41208c' })), hAsync("span", { key: 'de03b763d99f55b8773334df3d18c2d3855de4de', "aria-hidden": "true", part: "indicator", class: "indicator" }))));
+        return (hAsync(Host, { key: '4380fe35cacb11bc7114664c126504e8f4fb09a0' }, hAsync("button", { key: 'ac77443cbba5c94f864820088f60c0bac23d0775', part: "button", role: "tab", disabled: this.disabled, "aria-selected": String(this.selected), "aria-disabled": this.disabled ? 'true' : undefined, tabIndex: 0 }, hAsync("slot", { key: '9988497505ca3effa6c41011ac408a5d25629ca1', name: "media", ref: (el) => (this.mediaSlotEl = el), onSlotchange: this.handleMediaSlotChange }), hAsync("span", { key: '70566c46fba36b8717aa82917e45abd39cd7a2ea', class: "label" }, hAsync("slot", { key: 'a595738c387ee2f4f77f6ccdfdfb0589751ce999' })), hAsync("span", { key: '933758dc965d1151ca6a96367ea40290189384ad', "aria-hidden": "true", part: "indicator", class: "indicator" }))));
     }
     static get delegatesFocus() { return true; }
     static get style() { return lmvzTabCss(); }
@@ -12338,7 +15732,7 @@ class LmvzTabs extends ReactiveControllerHost {
         this.selectTab(value);
     };
     render() {
-        return (hAsync(Host, { key: '98df29f336a3ea47efa6c76a773de28c5174c718', onClick: this.handleTabClick, onKeydown: this.handleKeydown }, hAsync("div", { key: '7e35ae180c4ebf2f5a82e0fad0977cd3c38ac659', role: "tablist", "aria-orientation": this.orientation, class: "tablist" }, hAsync("slot", { key: '2520bc8b8988a60b37a067828ad237bf8dcfcc59', ref: (el) => (this.tabSlotEl = el) })), hAsync("div", { key: 'bd4a954b6caca2d9f2eb588f58590821ec4af888', part: "panels-container", class: "panels-container" }, hAsync("slot", { key: 'b4dffff530328e6e4c8d305895ef4dd2d5952757', name: "panels", ref: (el) => (this.panelSlotEl = el) }))));
+        return (hAsync(Host, { key: '33205038c047420618800be3ef755e1d13a0127c', onClick: this.handleTabClick, onKeydown: this.handleKeydown }, hAsync("div", { key: 'e803f772c5b187326fc80cfa2d3b9d74f6ee1df8', role: "tablist", "aria-orientation": this.orientation, class: "tablist" }, hAsync("slot", { key: '6871a7b6b26c6251ceb544c03b245450aa53373d', ref: (el) => (this.tabSlotEl = el) })), hAsync("div", { key: '17721962da2ecf107a5b878dea996812c61be998', part: "panels-container", class: "panels-container" }, hAsync("slot", { key: '485de66efc7812ecb2368a6b01b0d8ab63971497', name: "panels", ref: (el) => (this.panelSlotEl = el) }))));
     }
     static get watchers() { return {
         "value": [{
@@ -12369,7 +15763,7 @@ class LmvzTabs extends ReactiveControllerHost {
 
 const lmvzToggleCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } .sc-lmvz-toggle-h {   display: inline-flex;   align-items: center;   gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   padding-block: var(--lmvz-dimension-8-2, clamp(0.13rem, 0.03rem + 0.39vw, 0.5rem));   padding-inline: var(--lmvz-dimension-10-4, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));         border-radius: var(--lmvz-semantic-border-radius-round, 999px);   cursor: pointer;   background-color: transparent;   user-select: none; } .sc-lmvz-toggle-h:not([disabled]):hover {   background-color: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); } [checked].sc-lmvz-toggle-h {   background-color: var(--lmvz-semantic-color-status-active, #f6fbfe); } [disabled][checked].sc-lmvz-toggle-h {   background-color: var(--lmvz-semantic-color-status-active, #f6fbfe); } [disabled].sc-lmvz-toggle-h {   cursor: not-allowed;   opacity: var(--lmvz-component-input-disabled-opacity, 40%);   pointer-events: none; } .track.sc-lmvz-toggle {   position: relative;   flex-shrink: 0;   width: var(--lmvz-global-s32, 32px);   height: var(--lmvz-global-s20, 20px);   border-radius: var(--lmvz-semantic-border-radius-round, 999px);   background-color: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-border-default, #e0e0e0); } .sc-lmvz-toggle-h:not([disabled]):hover .track.sc-lmvz-toggle {   border-color: var(--lmvz-semantic-color-border-hover, #a1a1a1); } [checked].sc-lmvz-toggle-h .track.sc-lmvz-toggle {   border-color: var(--lmvz-semantic-color-border-active, #0f8acc); } input.sc-lmvz-toggle {      position: absolute;   top: 0;   left: 0;   width: 100%;   height: 100%;   opacity: 0;   margin: 0;   cursor: inherit; } .thumb.sc-lmvz-toggle {   position: absolute;   width: var(--lmvz-global-s13, 13px);   height: var(--lmvz-global-s13, 13px);   border-radius: 50%;   background-color: var(--lmvz-semantic-color-on-surface-input-secondary, #545454);   top: 50%;   transform: translateY(-50%);   left: var(--lmvz-global-s4, 4px);      transition:     left 0.2s ease,     background-color 0.2s ease;   pointer-events: none; } [checked].sc-lmvz-toggle-h .thumb.sc-lmvz-toggle {   left: calc(var(--lmvz-global-s4, 4px) + var(--lmvz-global-s11, 11px));   background-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4); } label.sc-lmvz-toggle {   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5 Router);   color: var(--lmvz-semantic-color-on-surface-primary, #000000);   cursor: pointer; }`;
 
-const focusWithinCss = () => `.sc-lmvz-toggle-h:focus-within{outline:var(--lmvz-ds-outline, 1px solid #0e7ab4);outline-offset:var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem))}@media (forced-colors: active){.sc-lmvz-toggle-h:focus-within{outline-color:Highlight;box-shadow:none}}`;
+const focusWithinCss = () => `.sc-lmvz-toggle-h:has(:focus-visible){outline:var(--lmvz-ds-outline, 1px solid #0e7ab4);outline-offset:var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem))}@media (forced-colors: active){.sc-lmvz-toggle-h:has(:focus-visible){outline-color:Highlight;box-shadow:none}}`;
 
 let toggleIdCounter = 0;
 class LmvzToggle extends ReactiveControllerHost {
@@ -12431,6 +15825,9 @@ class LmvzToggle extends ReactiveControllerHost {
     async reportValidity() {
         return this.nativeInputElement?.reportValidity?.() ?? false;
     }
+    async getValidationMessage() {
+        return this.nativeInputElement?.validationMessage ?? '';
+    }
     async getInputElement() {
         if (!this.nativeInputElement) {
             await new Promise((resolve) => componentOnReady(this.el, resolve));
@@ -12443,7 +15840,7 @@ class LmvzToggle extends ReactiveControllerHost {
         this.lmvzChange.emit(newChecked);
     };
     render() {
-        return (hAsync(Host, { key: '901f821ddae696fe877435bf20d08e4032cd61ee' }, hAsync("span", { key: 'bbac0ab3e40e426be511cc49a0dcb2497edd7a9a', class: "track" }, hAsync("input", { key: '1df7a78df28517189f690c6d453193e30d97d9ea', type: "checkbox", role: "switch", id: this.toggleId, checked: this.checked, disabled: this.disabled, required: this.required, name: this.name, value: this.value, form: this.form, ref: (el) => (this.nativeInputElement = el), onChange: this.handleChange }), hAsync("span", { key: 'e975c1c280983355f2504fba15553a9f19e4216f', class: "thumb", "aria-hidden": "true" })), hAsync("label", { key: '09b3305a1d0d6c116310cf88d1f8a92f6856f57e', htmlFor: this.toggleId }, this.label)));
+        return (hAsync(Host, { key: 'a0e0272a8457ee6b07a102aa10e5a7c0292a55d9' }, hAsync("span", { key: '5d14029bee4b66f5ed2ee1eb189a1d80a68abe3e', class: "track" }, hAsync("input", { key: '926b1ca6065750717577ece30e8e78b9004ec0e8', type: "checkbox", role: "switch", id: this.toggleId, checked: this.checked, disabled: this.disabled, required: this.required, name: this.name, value: this.value, form: this.form, ref: (el) => (this.nativeInputElement = el), onChange: this.handleChange }), hAsync("span", { key: 'bdee06bab6acba72d019134828f7415d7b347c49', class: "thumb", "aria-hidden": "true" })), hAsync("label", { key: 'b8eaa9305352f7146bf95bb517766310517d60e6', htmlFor: this.toggleId }, this.label)));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -12470,6 +15867,7 @@ class LmvzToggle extends ReactiveControllerHost {
             "blurToggle": [64],
             "checkValidity": [64],
             "reportValidity": [64],
+            "getValidationMessage": [64],
             "getInputElement": [64]
         },
         "$listeners$": undefined,
@@ -12486,6 +15884,7 @@ registerComponents([
   LmvzCard,
   LmvzCheckbox,
   LmvzChip,
+  LmvzDatepicker,
   LmvzHeader,
   LmvzIcon,
   LmvzInput,