@lmvz-ds/components 0.35.2 → 0.36.0

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());
 }
@@ -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;
@@ -8995,243 +9009,3030 @@ class LmvzChip extends ReactiveControllerHost {
     }; }
 }
 
-const logoSvg = 'data:image/svg+xml;base64,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';
-
-const lmvzHeaderCss = () => `:host{display:flex;width:100vw;flex-direction:row;align-items:center;box-sizing:border-box;background-color:var(--lmvz-semantic-color-surface-primary, #ffffff);--lmvz-header-x-spacing-level-1:var(--lmvz-dimension-28-8, clamp(0.5rem, 0.2rem + 1.29vw, 1.75rem));--lmvz-header-x-spacing-level-2:var(--lmvz-component-buttongroup-wrapper-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));padding:var(--lmvz-dimension-16-8, clamp(0.5rem, 0.38rem + 0.52vw, 1rem)) var(--lmvz-header-x-spacing-level-1);gap:var(--lmvz-header-x-spacing-level-1);.brand{display:inline-flex;justify-content:center;align-items:center}#fallback-logo-lmvz{height:34px;width:auto}nav{flex-grow:1}.primary-menubar{display:flex;flex-direction:row;align-items:center}.secondary-menubar{display:flex;flex-direction:row;align-items:center;margin-left:var(--lmvz-header-x-spacing-level-2);padding-left:var(--lmvz-header-x-spacing-level-2);border-left:1px solid var(--lmvz-semantic-color-border-default, #e0e0e0)}}`;
+// 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}`;
 
-class LmvzHeader extends ReactiveControllerHost {
-    get el() { return getElement(this); }
-    get validationEl() {
-        return this.el;
-    }
-    primarySlot;
-    secondarySlot;
-    secondaryNav;
-    keyboardNavigationController = new DirectionalFocusController(this, { orientation: 'both' });
-    get primaryMenuitems() {
-        return this.primarySlot?.assignedElements({ flatten: false }) || [];
-    }
-    get secondaryMenuitems() {
-        return this.secondarySlot?.assignedElements({ flatten: true }) || [];
-    }
-    get role() {
-        return 'banner';
-    }
-    lmvzActiveNav;
-    get secondarySlotName() {
-        return `connect-nav-${this.lmvzActiveNav}`;
-    }
-    constructor(hostRef) {
-        super();
-        registerInstance(this, hostRef);
-        this.addController(new AriaValidationController(this, { reValidateOnPropChanges: true }));
-        this.addController(this.keyboardNavigationController);
-    }
-    handleActiveNavChange() {
-        this.updateElementsActive();
-    }
-    async initFocus() {
-        this.keyboardNavigationController.initFocus();
-    }
-    componentDidLoad() {
-        this.primarySlot?.addEventListener('slotchange', this.handlePrimaryNavItemsChange.bind(this));
-        this.handlePrimaryNavItemsChange();
-        this.secondarySlot?.addEventListener('slotchange', this.handleSecondaryNavItemsChange.bind(this));
-        super.componentDidLoad();
-    }
-    handlePrimaryNavItemsChange() {
-        const items = this.primaryMenuitems;
-        if (!items.length) {
-            console.warn('Primary slot has no assigned elements. Please add navigation items to the primary slot.');
-            return;
-        }
-        items.forEach((el) => {
-            el.setAttribute('aria-haspopup', 'true');
-            el.setAttribute('aria-controls', `nav-secondary`);
-        });
-        this.updateElementsActive();
-        this.updateKeyboardNavSubjects();
+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);
     }
-    handleSecondaryNavItemsChange() {
-        const items = this.secondaryMenuitems;
-        if (!items.length) {
-            return;
-        }
-        this.updateKeyboardNavSubjects();
-    }
-    updateKeyboardNavSubjects() {
-        this.keyboardNavigationController.updateElements([...this.primaryMenuitems, ...this.secondaryMenuitems]);
+    return requireObjectLike(options);
+}
+function toFiniteNumber(arg, entityName = 'number') {
+    if (typeof arg === 'bigint') {
+        throw new TypeError(forbiddenBigIntToNumber(entityName));
     }
-    updateElementsActive() {
-        const items = this.primaryMenuitems;
-        if (!items.length)
-            return;
-        let label = '';
-        items.forEach((el) => {
-            const isActive = el.id === this.lmvzActiveNav;
-            if (isActive)
-                label = el.textContent || el.id;
-            el.setAttribute('aria-expanded', isActive ? 'true' : 'false');
-        });
-        if (!label)
-            return;
-        this.secondaryNav?.setAttribute('aria-label', `Untermenü für ${label}`);
+    arg = Number(arg);
+    if (!Number.isFinite(arg)) {
+        throw new RangeError(expectedFinite(entityName, arg));
     }
-    delegateFocus() {
-        const firstFocusable = this.primaryMenuitems[0];
-        if (firstFocusable) {
-            firstFocusable.focus();
-        }
+    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));
     }
-    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 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);
     }
-    static get watchers() { return {
-        "lmvzActiveNav": [{
-                "handleActiveNavChange": 0
-            }]
-    }; }
-    static get style() { return lmvzHeaderCss(); }
-    static get cmpMeta() { return {
-        "$flags$": 777,
-        "$tagName$": "lmvz-header",
-        "$members$": {
-            "role": [2561],
-            "lmvzActiveNav": [1, "lmvz-active-nav"],
-            "initFocus": [64]
-        },
-        "$listeners$": undefined,
-        "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["role", "role"]]
-    }; }
+    return arg;
 }
 
-const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));--lmvz-icon-size:var(--lmvz-component-size, var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem)));display:inline-block;line-height:0;svg{display:block;height:var(--lmvz-icon-size);width:auto}svg path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem))}}[size='sm'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.84rem + 0.13vw, 1rem))}}[size='md'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem))}}[size='lg'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-lg, clamp(1.25rem, 1.19rem + 0.26vw, 1.5rem))}}[size='inherit'].sc-lmvz-icon-h{svg{height:var(--lmvz-component-size, inherit)}}[weight='light'].sc-lmvz-icon-h{svg path{stroke-width:1}}[weight='medium'].sc-lmvz-icon-h{svg path{stroke-width:1.5}}[weight='bold'].sc-lmvz-icon-h{svg path{stroke-width:2}}[weight='filled'].sc-lmvz-icon-h{svg path{stroke-width:2;fill:var(--lmvz-icon-color)}}`;
+const invalidEntity = invalidEntity$1;
 
-class LmvzIcon extends ReactiveControllerHost {
-    intersectionObserver;
-    ariaValidationController = new AriaValidationController(this);
-    get el() { return getElement(this); }
-    validationEl;
-    icon;
-    weight = 'medium';
-    size = 'md';
-    iconset;
-    iconData;
-    visible = false;
-    ariaLabel;
-    get ariaHidden() {
-        return !this.ariaLabel;
-    }
-    constructor(hostRef) {
-        super();
-        registerInstance(this, hostRef);
-        this.addController(this.ariaValidationController);
-    }
-    connectedCallback() {
-        this.waitUntilVisible(() => {
-            this.visible = true;
-            this.loadIconPathData();
-        });
-        super.connectedCallback();
-    }
-    disconnectedCallback() {
-        if (this.intersectionObserver && typeof this.intersectionObserver.disconnect === 'function') {
-            this.intersectionObserver.disconnect();
-        }
-        this.intersectionObserver = undefined;
-        super.disconnectedCallback();
-    }
-    async loadIconPathData() {
-        {
-            return;
-        }
-    }
-    componentDidRender() {
-        this.validationEl = this.el.querySelector('svg');
-        this.ariaValidationController.revalidateAria();
-        super.componentDidRender();
-    }
-    render() {
-        return hAsync(Host, { key: '4fba217d573d968951819f12af24d775c8ac62dc', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
-    }
-    waitUntilVisible(callback, rootMargin = 50) {
-        {
-            callback();
-            return;
-        }
-    }
-    static get watchers() { return {
-        "icon": [{
-                "loadIconPathData": 0
-            }],
-        "iconset": [{
-                "loadIconPathData": 0
-            }]
-    }; }
-    static get style() { return lmvzIconCss(); }
-    static get cmpMeta() { return {
-        "$flags$": 514,
-        "$tagName$": "lmvz-icon",
-        "$members$": {
-            "icon": [513],
-            "weight": [513],
-            "size": [513],
-            "iconset": [513],
-            "ariaLabel": [513, "aria-label"],
-            "iconData": [32],
-            "visible": [32]
-        },
-        "$listeners$": undefined,
-        "$lazyBundleId$": "-",
-        "$attrsToReflect$": [["icon", "icon"], ["weight", "weight"], ["size", "size"], ["iconset", "iconset"], ["ariaLabel", "aria-label"]]
-    }; }
+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);
 }
 
-const nextFrame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
-const wait = () => new Promise((resolve) => setTimeout(() => resolve()));
-const waitFrame = async () => {
-    await wait();
-    await nextFrame();
-};
-const raf = (h) => {
-    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
-        return __zone_symbol__requestAnimationFrame(h);
-    }
-    if (typeof requestAnimationFrame === 'function') {
-        return requestAnimationFrame(h);
-    }
-    return setTimeout(h);
-};
+function throwTypeError(message) {
+  throw new TypeError(message);
+}
 
-const componentOnReady = (stencilEl, callback) => {
-    if (hasLazyBuild(stencilEl)) {
-        stencilEl.componentOnReady().then((resolvedEl) => callback(resolvedEl));
-    }
-    else {
-        raf(() => callback(stencilEl));
-    }
-};
-const hasLazyBuild = (stencilEl) => {
-    return stencilEl.componentOnReady !== undefined;
-};
+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);
+}
 
-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)); }`;
+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;
+}
 
-let inputIdCounter = 0;
-class LmvzInput extends ReactiveControllerHost {
-    get el() { return getElement(this); }
-    get validationEl() {
-        return this.el;
+function memoize(generator, MapClass = Map) {
+  const map = new MapClass;
+  return (key, ...otherArgs) => {
+    if (map.has(key)) {
+      return map.get(key);
     }
-    lmvzInput;
-    internals;
-    nativeInputElement;
-    inputId = `lmvz-input-${inputIdCounter++}`;
-    initialValue = '';
-    nativeError = false;
-    errorFromProp = false;
-    get helperId() {
+    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;
+        const validationLabels = getValidationLabels(this.locale);
+        this.internals.setValidity?.(flags, isInvalid ? this.errorMessage || validationLabels.invalidDateMessage : undefined, isInvalid ? this.el : undefined);
+    }
+    isInvalid = 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: 'df61136bb4d184e91e086a06f60e3c198f8a2b85' }, hAsync("lmvz-input", { key: '04986afb4a0926df4da693de6210ee4fccd74bd7', ref: (el) => {
+                this.inputEl = el;
+            }, label: this.label ?? '', placeholder: this.effectivePlaceholder, helperText: this.helperText, errorMessage: this.errorMessage, error: this.isInvalid, disabled: this.disabled, readonly: this.readonly, required: this.required, value: this.inputText, autocomplete: "off", onLmvzInput: this.handleInputTextChange, onKeyDown: this.handleInputKeydown }, hAsync("lmvz-icon", { key: '47897492e6df2f4b303c99aa33c48f326f3d9d63', slot: "after-input", icon: CALENDAR_ICON, "aria-hidden": "true" })), hAsync("lmvz-popover", { key: 'd2904def9519907f56dada15df992800da77db55', anchor: this.inputEl, open: this.open && !this.disabled, autoFocus: false, size: "md", label: popoverLabel, onLmvzOpen: this.handlePopoverOpen, onLmvzClose: this.handlePopoverClose }, hAsync("div", { key: 'dbdfe38144a63e5ac9de4c46e0df9918f898de28', 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],
+            "checkValidity": [64],
+            "reportValidity": [64]
+        },
+        "$listeners$": [[0, "keydown", "handleKeydown"], [0, "focusin", "handleInputFocus"], [0, "click", "handleInputFocus"]],
+        "$lazyBundleId$": "-",
+        "$attrsToReflect$": [["disabled", "disabled"], ["readonly", "readonly"], ["required", "required"], ["name", "name"], ["open", "open"]]
+    }; }
+}
+
+const logoSvg = 'data:image/svg+xml;base64,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';
+
+const lmvzHeaderCss = () => `:host{display:flex;width:100vw;flex-direction:row;align-items:center;box-sizing:border-box;background-color:var(--lmvz-semantic-color-surface-primary, #ffffff);--lmvz-header-x-spacing-level-1:var(--lmvz-dimension-28-8, clamp(0.5rem, 0.2rem + 1.29vw, 1.75rem));--lmvz-header-x-spacing-level-2:var(--lmvz-component-buttongroup-wrapper-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));padding:var(--lmvz-dimension-16-8, clamp(0.5rem, 0.38rem + 0.52vw, 1rem)) var(--lmvz-header-x-spacing-level-1);gap:var(--lmvz-header-x-spacing-level-1);.brand{display:inline-flex;justify-content:center;align-items:center}#fallback-logo-lmvz{height:34px;width:auto}nav{flex-grow:1}.primary-menubar{display:flex;flex-direction:row;align-items:center}.secondary-menubar{display:flex;flex-direction:row;align-items:center;margin-left:var(--lmvz-header-x-spacing-level-2);padding-left:var(--lmvz-header-x-spacing-level-2);border-left:1px solid var(--lmvz-semantic-color-border-default, #e0e0e0)}}`;
+
+class LmvzHeader extends ReactiveControllerHost {
+    get el() { return getElement(this); }
+    get validationEl() {
+        return this.el;
+    }
+    primarySlot;
+    secondarySlot;
+    secondaryNav;
+    keyboardNavigationController = new DirectionalFocusController(this, { orientation: 'both' });
+    get primaryMenuitems() {
+        return this.primarySlot?.assignedElements({ flatten: false }) || [];
+    }
+    get secondaryMenuitems() {
+        return this.secondarySlot?.assignedElements({ flatten: true }) || [];
+    }
+    get role() {
+        return 'banner';
+    }
+    lmvzActiveNav;
+    get secondarySlotName() {
+        return `connect-nav-${this.lmvzActiveNav}`;
+    }
+    constructor(hostRef) {
+        super();
+        registerInstance(this, hostRef);
+        this.addController(new AriaValidationController(this, { reValidateOnPropChanges: true }));
+        this.addController(this.keyboardNavigationController);
+    }
+    handleActiveNavChange() {
+        this.updateElementsActive();
+    }
+    async initFocus() {
+        this.keyboardNavigationController.initFocus();
+    }
+    componentDidLoad() {
+        this.primarySlot?.addEventListener('slotchange', this.handlePrimaryNavItemsChange.bind(this));
+        this.handlePrimaryNavItemsChange();
+        this.secondarySlot?.addEventListener('slotchange', this.handleSecondaryNavItemsChange.bind(this));
+        super.componentDidLoad();
+    }
+    handlePrimaryNavItemsChange() {
+        const items = this.primaryMenuitems;
+        if (!items.length) {
+            console.warn('Primary slot has no assigned elements. Please add navigation items to the primary slot.');
+            return;
+        }
+        items.forEach((el) => {
+            el.setAttribute('aria-haspopup', 'true');
+            el.setAttribute('aria-controls', `nav-secondary`);
+        });
+        this.updateElementsActive();
+        this.updateKeyboardNavSubjects();
+    }
+    handleSecondaryNavItemsChange() {
+        const items = this.secondaryMenuitems;
+        if (!items.length) {
+            return;
+        }
+        this.updateKeyboardNavSubjects();
+    }
+    updateKeyboardNavSubjects() {
+        this.keyboardNavigationController.updateElements([...this.primaryMenuitems, ...this.secondaryMenuitems]);
+    }
+    updateElementsActive() {
+        const items = this.primaryMenuitems;
+        if (!items.length)
+            return;
+        let label = '';
+        items.forEach((el) => {
+            const isActive = el.id === this.lmvzActiveNav;
+            if (isActive)
+                label = el.textContent || el.id;
+            el.setAttribute('aria-expanded', isActive ? 'true' : 'false');
+        });
+        if (!label)
+            return;
+        this.secondaryNav?.setAttribute('aria-label', `Untermenü für ${label}`);
+    }
+    delegateFocus() {
+        const firstFocusable = this.primaryMenuitems[0];
+        if (firstFocusable) {
+            firstFocusable.focus();
+        }
+    }
+    render() {
+        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": [{
+                "handleActiveNavChange": 0
+            }]
+    }; }
+    static get style() { return lmvzHeaderCss(); }
+    static get cmpMeta() { return {
+        "$flags$": 777,
+        "$tagName$": "lmvz-header",
+        "$members$": {
+            "role": [2561],
+            "lmvzActiveNav": [1, "lmvz-active-nav"],
+            "initFocus": [64]
+        },
+        "$listeners$": undefined,
+        "$lazyBundleId$": "-",
+        "$attrsToReflect$": [["role", "role"]]
+    }; }
+}
+
+const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));--lmvz-icon-size:var(--lmvz-component-size, var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem)));display:inline-block;line-height:0;svg{display:block;height:var(--lmvz-icon-size);width:auto}svg path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem))}}[size='sm'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.84rem + 0.13vw, 1rem))}}[size='md'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem))}}[size='lg'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-lg, clamp(1.25rem, 1.19rem + 0.26vw, 1.5rem))}}[size='inherit'].sc-lmvz-icon-h{svg{height:var(--lmvz-component-size, inherit)}}[weight='light'].sc-lmvz-icon-h{svg path{stroke-width:1}}[weight='medium'].sc-lmvz-icon-h{svg path{stroke-width:1.5}}[weight='bold'].sc-lmvz-icon-h{svg path{stroke-width:2}}[weight='filled'].sc-lmvz-icon-h{svg path{stroke-width:2;fill:var(--lmvz-icon-color)}}`;
+
+class LmvzIcon extends ReactiveControllerHost {
+    intersectionObserver;
+    ariaValidationController = new AriaValidationController(this);
+    get el() { return getElement(this); }
+    validationEl;
+    icon;
+    weight = 'medium';
+    size = 'md';
+    iconset;
+    iconData;
+    visible = false;
+    ariaLabel;
+    get ariaHidden() {
+        return !this.ariaLabel;
+    }
+    constructor(hostRef) {
+        super();
+        registerInstance(this, hostRef);
+        this.addController(this.ariaValidationController);
+    }
+    connectedCallback() {
+        this.waitUntilVisible(() => {
+            this.visible = true;
+            this.loadIconPathData();
+        });
+        super.connectedCallback();
+    }
+    disconnectedCallback() {
+        if (this.intersectionObserver && typeof this.intersectionObserver.disconnect === 'function') {
+            this.intersectionObserver.disconnect();
+        }
+        this.intersectionObserver = undefined;
+        super.disconnectedCallback();
+    }
+    async loadIconPathData() {
+        {
+            return;
+        }
+    }
+    componentDidRender() {
+        this.validationEl = this.el.querySelector('svg');
+        this.ariaValidationController.revalidateAria();
+        super.componentDidRender();
+    }
+    render() {
+        return hAsync(Host, { key: 'be6032d11399289c3baddd63ebc7d9e1fb98b773', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
+    }
+    waitUntilVisible(callback, rootMargin = 50) {
+        {
+            callback();
+            return;
+        }
+    }
+    static get watchers() { return {
+        "icon": [{
+                "loadIconPathData": 0
+            }],
+        "iconset": [{
+                "loadIconPathData": 0
+            }]
+    }; }
+    static get style() { return lmvzIconCss(); }
+    static get cmpMeta() { return {
+        "$flags$": 514,
+        "$tagName$": "lmvz-icon",
+        "$members$": {
+            "icon": [513],
+            "weight": [513],
+            "size": [513],
+            "iconset": [513],
+            "ariaLabel": [513, "aria-label"],
+            "iconData": [32],
+            "visible": [32]
+        },
+        "$listeners$": undefined,
+        "$lazyBundleId$": "-",
+        "$attrsToReflect$": [["icon", "icon"], ["weight", "weight"], ["size", "size"], ["iconset", "iconset"], ["ariaLabel", "aria-label"]]
+    }; }
+}
+
+const nextFrame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
+const wait = () => new Promise((resolve) => setTimeout(() => resolve()));
+const waitFrame = async () => {
+    await wait();
+    await nextFrame();
+};
+const raf = (h) => {
+    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+
+const componentOnReady = (stencilEl, callback) => {
+    if (hasLazyBuild(stencilEl)) {
+        stencilEl.componentOnReady().then((resolvedEl) => callback(resolvedEl));
+    }
+    else {
+        raf(() => callback(stencilEl));
+    }
+};
+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)); }`;
+
+let inputIdCounter = 0;
+class LmvzInput extends ReactiveControllerHost {
+    get el() { return getElement(this); }
+    get validationEl() {
+        return this.el;
+    }
+    lmvzInput;
+    internals;
+    nativeInputElement;
+    inputId = `lmvz-input-${inputIdCounter++}`;
+    initialValue = '';
+    ariaHostMirrorObserver;
+    nativeError = false;
+    errorFromProp = false;
+    get helperId() {
         return this.helperText ? `${this.inputId}-helper` : undefined;
     }
     get showErrorMessage() {
@@ -9328,6 +12129,42 @@ 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;
@@ -9375,9 +12212,9 @@ class LmvzInput extends ReactiveControllerHost {
     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: 'b7e432c7dbc598189d85040252455c5163fe6395', 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: 'a912a49f4372423d06c7a4856fb5101cb0afd0c5', class: "input-wrapper" }, hAsync("slot", { key: '88e4ee4518de0bfeef9e30a254e0d2ec6693048c', name: "before-input" }), hAsync("div", { key: 'a413a7b7e8f6510f1c09fd0052889c8fad1653f1', class: "label-input-group" }, hAsync("label", { key: '9639713adff74afcf4fb1eab0e74b7447d02b986', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (hAsync("span", { key: '28c1069908a2f1905008f1decce9077e9ef1538a', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), hAsync("input", { key: '421fd9bb50de8ba189a59578373060593e1a9aab', 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: '09557e1d84bb4ab2456caf391a177c8f80063ab9', name: "after-input" })), hAsync("div", { key: '34162f744f8584991e4493ebcdb6a2f75a1f8990', id: this.helperId, role: "status" }, this.helperText || null), hAsync("div", { key: 'a3c3bffbb439f9127278cedbfefa5e1986e68f23', id: this.errorId, role: "alert" }, (this.showErrorMessage && this.errorMessage) || null)));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -9483,7 +12320,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 +12368,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 +12486,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 +12730,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": [{
@@ -11349,6 +14186,9 @@ class LmvzPopover {
             anchorEl.setAttribute('aria-haspopup', 'dialog');
         }
         anchorEl.setAttribute('aria-controls', this.el.getAttribute('id'));
+        if (!anchorEl.hasAttribute('aria-expanded')) {
+            anchorEl.setAttribute('aria-expanded', this.open ? 'true' : 'false');
+        }
         if (isActionButton(anchorEl)) {
             addElementActivationListener(anchorEl, this.toggle.bind(this), this.extEventController.signal);
         }
@@ -11434,7 +14274,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 +14291,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: 'f996d0a561b8f6d00913b0e2e84ac9711b878f84' }, hAsync("div", { key: 'f7fff89cf470a96b0d3d2adce43a92069d754861', role: "dialog", part: "container", class: `container lmvz-wrapper-card-${this.size}`, "aria-label": this.label || undefined, ref: (el) => (this.containerEl = el) }, hAsync("slot", { key: '2263710272a745d74f118fab6d22f0d05319fc74', ref: (el) => (this.slotEl = el) }))));
     }
     static get watchers() { return {
         "open": [{
@@ -11823,7 +14664,7 @@ class LmvzRadio extends ReactiveControllerHost {
         this.radioGroupController.setFocused(target);
     }
     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: 'cb2db48956ca781f226fbbddcf1d8ea819f9192a' }, hAsync("input", { key: 'ec208dbaa714ae015415370b0d38ef916955b023', 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: 'ef8221077d410d59248ce30678989f6bf7fbbebb', class: "circle", "aria-hidden": "true" }, this.checked && hAsync("span", { key: '7faa45b58d39f05f64a7782329046fe07b0c2a98', class: "dot" })), hAsync("span", { key: 'e508b4bf061ab0e038df7c169a80285bb7930dc3', class: "content" }, hAsync("label", { key: '8117be47e7b0ae9cc17bab21bb7cc5d9300d2146', htmlFor: this.radioId }, this.label), hAsync("span", { key: '44ab845ee18415b54fb5d23e533f85644f4e5e50', "aria-live": "polite", class: "helper-text", id: this.helperId }, this.helperText))));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -11916,7 +14757,7 @@ class LmvzSelect extends ReactiveControllerHost {
     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: '764be3255f76406e66600e800da85d84de8a5b62', "data-highlighted": String(this.highlighted) }, hAsync("div", { key: '81c6c1eb04d9062b142f30c201b3ec24feec8814', class: hasValue ? 'select-wrapper has-value' : 'select-wrapper' }, hAsync("label", { key: '49199adcb31515ce4b4789f27cc2520805c29a3c', htmlFor: this.selectId, class: shouldShowLabel ? 'floating-label' : 'assistive-label' }, this.label, this.required && shouldShowLabel && hAsync("span", { key: 'e7e02e878d8a130d61e426774d9d362a49e481a7', "aria-hidden": "true" }, " *")), hAsync("div", { key: 'bc5ff1214d856a084918c8e68d1b1567a97b41bb', "aria-hidden": "true" }, hAsync("span", { key: 'cc3513a16e4e621bc47f35c252e981bc25bc0d77' }, hasValue ? this.selectedLabel : this.label, this.required && !hasValue && hAsync("span", { key: 'a34658592f038b9438808418cc106842d98e63d5', "aria-hidden": "true" }, " *")), hAsync("span", { key: 'cd71dd492d758e7e53e6212cc9549ec4057abe3f' }, hAsync("svg", { key: 'fa1ea83d316fa9280516316b695163634264151c', width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true" }, hAsync("path", { key: '7750c64531e98cc5cdebafa1ecacf624945ab198', 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: '53a4e34ad1405447177675e67afcc2e9c18319cb', 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: '78ba2e2225d3d3b558c8a20f276f6fbbc0a670b8', value: "", disabled: true, selected: true, hidden: true }), hAsync("slot", { key: 'bbc561f3f55dbc42b705f251fdc146b0496c72a1' }))), this.helperText && hAsync("div", { key: '5bc860035c0ee46f62fefdb74d752b419bb19f7c', role: "status" }, this.helperText)));
     }
     static get watchers() { return {
         "value": [{
@@ -12008,7 +14849,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: '3526d31aa5842f2d4bf5b5b878a7ca03bb4bf731', class: this.animationClass }, hAsync("lmvz-icon", { key: '52080f476e527c9af337eb1997db1b29a90fb5c0', icon: STATUS_SVG[this.status], size: "md", weight: "bold" }), hAsync("span", { key: 'a18eaf04ca959432fc76037efd24ecf1001bd798', class: "message" }, this.message), this.actionLabel && (hAsync("lmvz-button", { key: '3126781af40ea74854db8e7c2aa7e1fb1b632d38', variant: "tertiary", scale: "small", onLmvzActivation: this.handleActionClick }, this.actionLabel))));
     }
     static get watchers() { return {
         "status": [{
@@ -12045,7 +14886,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: '96a151ca5586df967f9973e73cfb7be458254dc4', role: hasLabel ? 'status' : undefined, "aria-label": hasLabel ? this.ariaLabel : undefined, "aria-hidden": hasLabel ? undefined : 'true' }, hAsync("svg", { key: '27d404b929294aba50170e0ad4951c0c03d7a286', part: "indicator", viewBox: "0 0 16 16", "aria-hidden": "true" }, hAsync("circle", { key: 'bcf47ee3a704f46ab4ec26de41dd859db17266e9', pathLength: "100", cx: "8", cy: "8", r: "6" }))));
     }
     static get style() { return lmvzSpinnerCss(); }
     static get cmpMeta() { return {
@@ -12081,7 +14922,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: '992500dcc371efbeab4eb83fbcfb9745384fa423' }, hAsync("button", { key: 'e346c88625b701636704e89b749971e6a016a3ff', part: "button", role: "tab", disabled: this.disabled, "aria-selected": String(this.selected), "aria-disabled": this.disabled ? 'true' : undefined, tabIndex: 0 }, hAsync("slot", { key: 'ee0790e6f04c1c05fbbb7a624e0c791e1db24506', name: "media", ref: (el) => (this.mediaSlotEl = el), onSlotchange: this.handleMediaSlotChange }), hAsync("span", { key: '45b0c2c38dcec72ab02cd308e0301d1c912e96f7', class: "label" }, hAsync("slot", { key: 'e31e6c8ade0c7b44684836c29fbb65464db7ae59' })), hAsync("span", { key: '03016f465e673bf27261e8ceb5c3a6a1666551a7', "aria-hidden": "true", part: "indicator", class: "indicator" }))));
     }
     static get delegatesFocus() { return true; }
     static get style() { return lmvzTabCss(); }
@@ -12338,7 +15179,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: '27d096ac6ed21fb72a5c6336c6f07ee2fe36bd92', onClick: this.handleTabClick, onKeydown: this.handleKeydown }, hAsync("div", { key: 'c3b530f13cf6829e8519a678e577e8aa6bf1c3d6', role: "tablist", "aria-orientation": this.orientation, class: "tablist" }, hAsync("slot", { key: '018641f52dfcab6dea884c95a5e550dbe60f74f6', ref: (el) => (this.tabSlotEl = el) })), hAsync("div", { key: '6f7cce2b8e551683ba04c53ebae8233c3ef61969', part: "panels-container", class: "panels-container" }, hAsync("slot", { key: '8e9f0c1e1866180a763dd41aa1974f5cf354fb44', name: "panels", ref: (el) => (this.panelSlotEl = el) }))));
     }
     static get watchers() { return {
         "value": [{
@@ -12443,7 +15284,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: 'bde08dcbd39c0c02602590bc0c536b5d671fa76e' }, hAsync("span", { key: '2567f70f81014d8ab7b9073a0d59f33bfeeca6a5', class: "track" }, hAsync("input", { key: '88c9fc7523489dd0decf5b5f3ddda604aadcf8a9', 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: '816fc007d7c87acc8ff0286eb861bd29059b44eb', class: "thumb", "aria-hidden": "true" })), hAsync("label", { key: '9525cd785d2c6c3b6242c6f5eac215996b881873', htmlFor: this.toggleId }, this.label)));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -12486,6 +15327,7 @@ registerComponents([
   LmvzCard,
   LmvzCheckbox,
   LmvzChip,
+  LmvzDatepicker,
   LmvzHeader,
   LmvzIcon,
   LmvzInput,