@lmvz-ds/components 0.17.3 → 0.18.1

package/hydrate/index.js

@@ -4153,7 +4153,7 @@ var braceExpand = (pattern, options = {}) => {
 minimatch.braceExpand = braceExpand;
 var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
 minimatch.makeRe = makeRe;
-var match$1 = (list, pattern, options = {}) => {
+var match = (list, pattern, options = {}) => {
   const mm = new Minimatch(pattern, options);
   list = list.filter((f) => mm.match(f));
   if (mm.options.nonull && !list.length) {
@@ -4161,7 +4161,7 @@ var match$1 = (list, pattern, options = {}) => {
   }
   return list;
 };
-minimatch.match = match$1;
+minimatch.match = match;
 var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
 var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 var _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn;
@@ -5359,7 +5359,7 @@ class LmvzAction {
         this.actionClick.emit(event);
     }
     render() {
-        return (hAsync(Host, { key: '15c0f20e08cd5019abfd3bb71ec69d175dc5ba48', onClick: this._onClick.bind(this) }, hAsync("slot", { key: 'f71a7853168d1b66b0a50b0f971d140385530ac3' })));
+        return (hAsync(Host, { key: '00da873d80f00dc57e5a0d60f2b58a6c505e41f1', onClick: this._onClick.bind(this) }, hAsync("slot", { key: '7938b5e172ef2b027180aac801b0d9962cd68fa5' })));
     }
     static get style() { return lmvzActionCss(); }
     static get cmpMeta() { return {
@@ -5483,7 +5483,10 @@ function resolvePossiblyAsyncFunction(func, args = []) {
     return Promise.resolve(res);
 }
 
-const GLOBAL_STATE_KEY = Symbol('__lmvzAriaValidationRuntimeState');
+const hasProcessStdout = typeof process === "object" && process !== null && typeof process.stdout === "object" && process.stdout !== null;
+hasProcessStdout && process.stdout.isTTY === true;
+
+const GLOBAL_STATE_KEY = Symbol('LMVZ__ariaValidationRuntimeState');
 const ARIA_VALIDATION_RUNTIME_CHANGED_EVENT = 'lmvz:aria-validation-runtime-changed';
 function getRuntimeState() {
     const globalState = globalThis;
@@ -5584,25 +5587,6 @@ class AriaValidationController {
         this.host.validationSlot?.addEventListener('slotchange', this.enqueueValidation.bind(this));
     }
     observeVisibilityOnce() {
-        window.setTimeout(() => {
-            if (!this.host.validationEl)
-                return;
-            this.visibilityObserver = new IntersectionObserver((entries) => {
-                for (const entry of entries) {
-                    if (entry.target !== this.host.validationEl)
-                        continue;
-                    if (!entry.isIntersecting)
-                        continue;
-                    this.checkLazyValidation();
-                    this.discardVisibilityObserver();
-                }
-            }, {
-                root: this.host.validationEl?.parentElement,
-                rootMargin: '0px',
-                threshold: 0.01,
-            });
-            this.visibilityObserver.observe(this.host.validationEl);
-        });
     }
     checkLazyValidation() {
         if (!this.elementLoaded)
@@ -5663,10 +5647,6 @@ class AriaValidationController {
         });
     }
     discardVisibilityObserver() {
-        if (!this.visibilityObserver)
-            return;
-        this.visibilityObserver.disconnect();
-        this.visibilityObserver = undefined;
     }
 }
 
@@ -5871,7 +5851,7 @@ class ReactiveControllerHost {
     }
 }
 
-const lmvzButtonCss = () => ` @layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } @layer lmvz-ds.reset { body {   margin: 0; }  h1, h2, h3, h4, h5, h6 {   margin: 0; }  } :host {         button {   --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-primary, #ffffff));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {      outline: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-status-selected, #f1f9fe);   outline-offset: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0); }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-hover, #c7c7c7); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-active, #d4d4d4); }    button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #545454); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); }    button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-padding-block: var(--lmvz-component-input-sm-padding-y, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-gap: var(--lmvz-component-input-sm-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-lg-padding-x, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-lg-padding-y, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-lg-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router); }     display: contents; } ::slotted(*) {   --lmvz-component-color: var(--lmvz-button-color); } `;
+const lmvzButtonCss = () => ` @layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } @layer lmvz-ds.reset { body {   margin: 0; }  h1, h2, h3, h4, h5, h6 {   margin: 0; }  } :host {         button {   --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-primary, #ffffff));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {      outline: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-status-active, #f1f9fe);   outline-offset: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0); }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-hover, #c7c7c7); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-active, #0f8acc); }    button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #545454); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); }    button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-padding-block: var(--lmvz-component-input-sm-padding-y, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-gap: var(--lmvz-component-input-sm-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-lg-padding-x, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-lg-padding-y, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-lg-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router); }     display: contents; } ::slotted(*) {   --lmvz-component-color: var(--lmvz-button-color); } `;
 
 class LmvzButton extends ReactiveControllerHost {
     get el() { return getElement(this); }
@@ -5928,7 +5908,7 @@ class LmvzButton extends ReactiveControllerHost {
     };
     render() {
         this.renderHiddenButton();
-        return (hAsync(Host, { key: 'c6f44d3765d579e04ab91272747035d8589e2ff2', "aria-disabled": this.disabled ? 'true' : null }, hAsync("button", { key: '9d48dfc7a6a23df1eda46e9c9035520789a08d4c', ref: (e) => (this.validationEl = e), disabled: this.disabled, class: classNames(this.variant, { [this.scale ?? '']: !!this.scale, disabled: this.disabled }), ...this.inheritedAttributes }, hAsync("slot", { key: '95e9fb932e477c7d6e933d2c00e6a3728e55c256' }))));
+        return (hAsync(Host, { key: '1448b16151418790d0a78eda2248b7d61fd8e32b', "aria-disabled": this.disabled ? 'true' : null }, hAsync("button", { key: '2cf7ccc0692179b68aaea534a7a4d11dbcbe27b5', ref: (e) => (this.validationEl = e), disabled: this.disabled, class: classNames(this.variant, { [this.scale ?? '']: !!this.scale, disabled: this.disabled }), ...this.inheritedAttributes }, hAsync("slot", { key: '8fd9f99f8c79657fd3dbeafb2fd88ca667bc0d44' }))));
     }
     static get delegatesFocus() { return true; }
     static get style() { return lmvzButtonCss(); }
@@ -5969,7 +5949,7 @@ function joinPath(...parts) {
     return parts.filter(Boolean).join('/').replace('//', '/').replace('/./', '/');
 }
 
-const lmvzCardCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } @layer lmvz-ds.reset { body {   margin: 0; }  h1, h2, h3, h4, h5, h6 {   margin: 0; }  } .sc-lmvz-card-h {            button {   --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-primary, #ffffff));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {      outline: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-status-selected, #f1f9fe);   outline-offset: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0); }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-hover, #c7c7c7); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-active, #d4d4d4); }    button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #545454); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); }    button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-padding-block: var(--lmvz-component-input-sm-padding-y, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-gap: var(--lmvz-component-input-sm-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-lg-padding-x, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-lg-padding-y, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-lg-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router); }     display: flex;   min-width: var(--lmvz-other-component-card-minwidth, 20.4375rem);   max-width: var(--lmvz-other-component-card-maxwidth, 21.6875rem);   flex-direction: column;   align-items: flex-start;    border-radius: var(--lmvz-semantic-border-radius-lg, 14px);   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-border-default, #e0e0e0);   background: var(--lmvz-semantic-color-surface-primary, #ffffff); } *.sc-lmvz-card {   color: var(--lmvz-semantic-color-on-surface-primary, #000000);   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); } .top.sc-lmvz-card {   display: flex;   padding: var(--lmvz-dimension-8-12, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   flex-direction: column;   justify-content: center;   align-items: center;   align-self: stretch; } .bottom.sc-lmvz-card {   display: flex;   min-width: 150px;   padding: var(--lmvz-dimension-4-6, clamp(0.25rem, 0.22rem + 0.13vw, 0.38rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem));   flex-direction: column;   align-items: flex-start;   align-self: stretch; } .title.sc-lmvz-card {   margin: 0;   display: flex;   justify-content: center;   align-items: center;   align-self: stretch;    padding-bottom: var(--lmvz-global-s4, 4px);   overflow-wrap: break-word;   font: var(--lmvz-typography-heading-2xl, 500 clamp(2rem, 1.94rem + 0.26vw, 2.25rem) / 1.2     Router); } .description.sc-lmvz-card {   display: flex;   margin: 0;   padding-bottom: var(--lmvz-component-body-sm-padding-bottom, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   align-items: flex-start;   align-self: stretch;   white-space: pre-line;   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); } .image-wrapper.sc-lmvz-card {   aspect-ratio: 4 / 3;   width: 100%;   background-size: cover;   background-position: center;   flex: 1 0 0;   align-self: stretch;   border-radius: var(--lmvz-semantic-border-radius-md, 6px); } .actions.sc-lmvz-card {   margin-top: var(--lmvz-component-form-wrapper-gap-y, clamp(1.13rem, 0.97rem + 0.65vw, 1.75rem));   display: flex;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   align-self: stretch; } button.primary.sc-lmvz-card, lmvz-button.primary.sc-lmvz-card {   display: flex;   justify-content: center;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   flex: 1 0 0; }`;
+const lmvzCardCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } @layer lmvz-ds.reset { body {   margin: 0; }  h1, h2, h3, h4, h5, h6 {   margin: 0; }  } .sc-lmvz-card-h {            button {   --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-primary, #ffffff));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {      outline: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-status-active, #f1f9fe);   outline-offset: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0); }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-hover, #c7c7c7); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-active, #0f8acc); }    button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #545454); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); }    button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-padding-block: var(--lmvz-component-input-sm-padding-y, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-gap: var(--lmvz-component-input-sm-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-lg-padding-x, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-lg-padding-y, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-lg-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router); }     display: flex;   min-width: var(--lmvz-card-component-card-minwidth, 20.4375rem);   max-width: var(--lmvz-card-component-card-maxwidth, 21.6875rem);   flex-direction: column;   align-items: flex-start;    border-radius: var(--lmvz-semantic-border-radius-lg, 14px);   border: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-border-default, #e0e0e0);   background: var(--lmvz-semantic-color-surface-primary, #ffffff); } *.sc-lmvz-card {   color: var(--lmvz-semantic-color-on-surface-primary, #000000);   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); } .top.sc-lmvz-card {   display: flex;   padding: var(--lmvz-dimension-8-12, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   flex-direction: column;   justify-content: center;   align-items: center;   align-self: stretch; } .bottom.sc-lmvz-card {   display: flex;   min-width: 150px;   padding: var(--lmvz-dimension-4-6, clamp(0.25rem, 0.22rem + 0.13vw, 0.38rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem)) var(--lmvz-dimension-10-14, clamp(0.63rem, 0.56rem + 0.26vw, 0.88rem));   flex-direction: column;   align-items: flex-start;   align-self: stretch; } .title.sc-lmvz-card {   margin: 0;   display: flex;   justify-content: center;   align-items: center;   align-self: stretch;    padding-bottom: var(--lmvz-global-s4, 4px);   overflow-wrap: break-word;   font: var(--lmvz-typography-heading-2xl, 500 clamp(2.25rem, 2.13rem + 0.52vw, 2.75rem) / 1.2     Router); } .description.sc-lmvz-card {   display: flex;   margin: 0;   padding-bottom: var(--lmvz-component-body-sm-padding-bottom, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   align-items: flex-start;   align-self: stretch;   white-space: pre-line;   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); } .image-wrapper.sc-lmvz-card {   aspect-ratio: 4 / 3;   width: 100%;   background-size: cover;   background-position: center;   flex: 1 0 0;   align-self: stretch;   border-radius: var(--lmvz-semantic-border-radius-md, 6px); } .actions.sc-lmvz-card {   margin-top: var(--lmvz-component-form-wrapper-gap-y, clamp(1.13rem, 0.97rem + 0.65vw, 1.75rem));   display: flex;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   align-self: stretch; } button.primary.sc-lmvz-card, lmvz-button.primary.sc-lmvz-card {   display: flex;   justify-content: center;   align-items: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   flex: 1 0 0; }`;
 
 class LmvzCard {
     constructor(hostRef) {
@@ -5994,7 +5974,7 @@ class LmvzCard {
         const imgStyle = {
             backgroundImage: `url(${this.imageUrl ?? this.fallbackImage})`,
         };
-        return (hAsync(Host, { key: '46c2832b4f90b9eb222749632bc7ad59cd645e10', role: "article" }, hAsync("div", { key: 'cc387fe96cff2dd04c24f75cf838a2bf6f438279', class: "top" }, hAsync("div", { key: 'f9a54a5f81378ef4265e1d74c36c78af002e8874', class: "image-wrapper", style: imgStyle }, hAsync("div", { key: '76daed00408f7ae9ee46977637ddcd3d4f846380', class: "chip-slot" }, hAsync("slot", { key: '6ad522ef7428166b876d0218ef8d801c4ef337f1', name: "chip" })))), hAsync("div", { key: '9c9799668ac199cfecbe10061e271d70d70e2d07', class: "bottom" }, hAsync("header", { key: '1bec743235bea5c7ab163225ffbd7bc6cf11f754' }, hAsync("h2", { key: '06f8e14153328bc5ca920e71e09d9343047c440c', class: "title" }, this.cardTitle)), hAsync("p", { key: '86b95db4e6464ca3236b4a03798013c3580819bf', class: "description" }, this.description), hAsync("div", { key: '553dc998d5318a4730196baa0b9baff3a0a3369f', class: "actions" }, hAsync("button", { key: '7532d01b46769198c23a1b1015c187fdefce146a', class: "primary", onClick: this._onPrimaryClick.bind(this), "data-testid": "primary" }, this.primaryActionLabel), hAsync("button", { key: '633d679ae59b1896aa2a06e04b4564569cf27a7d', class: "tertiary", "aria-label": "More actions", onClick: this._onOverflowClick }, hAsync("span", { key: 'b72c45f93d259502b9d7c5ffb19e292a53c60ec6', class: "icon-placeholder" }, "..."))))));
+        return (hAsync(Host, { key: 'fceb19eb0d7ad6c6aecfa6fbd5bb6425c7c3e312', role: "article" }, hAsync("div", { key: '4cb516b5dee1f2f84f21984fa350f61fd83c771c', class: "top" }, hAsync("div", { key: '713b2a3245d885a9b99f6c7d54a35053699c1be8', class: "image-wrapper", style: imgStyle }, hAsync("div", { key: 'e8ea65e7f5d11a2335cab950d6bf02208d0b18a1', class: "chip-slot" }, hAsync("slot", { key: 'e9a039742107fdf56216186ddcdf367c4432790b', name: "chip" })))), hAsync("div", { key: '9549e46a1872e0edf298b79435d298aa1ae96a37', class: "bottom" }, hAsync("header", { key: '3bbfb72ecec519d16380ae7e00da4b1ccb6f1cf3' }, hAsync("h2", { key: 'f5a33e498893e61b407c10ab36c9a93b7eecf9f1', class: "title" }, this.cardTitle)), hAsync("p", { key: '19709bb100d014369c836a5a7174772f2d095d2e', class: "description" }, this.description), hAsync("div", { key: '06b5acab3c80cc91865f3aa39da32d42f470348e', class: "actions" }, hAsync("button", { key: '4e954452ac9771359c881aa6b43f11e89e38aecf', class: "primary", onClick: this._onPrimaryClick.bind(this), "data-testid": "primary" }, this.primaryActionLabel), hAsync("button", { key: 'b6a682bf95eb26468c450bed494290565288a515', class: "tertiary", "aria-label": "More actions", onClick: this._onOverflowClick }, hAsync("span", { key: '70a526d1fafd8b7051f6e7107b35d6f594e10d68', class: "icon-placeholder" }, "..."))))));
     }
     static get assetsDirs() { return ["../../assets"]; }
     static get style() { return lmvzCardCss(); }
@@ -6021,7 +6001,7 @@ class LmvzChip {
     }
     text;
     render() {
-        return hAsync(Host, { key: 'd128e24bb90891ebd13d13a8e27c06782363cace' }, this.text);
+        return hAsync(Host, { key: '134d510fe3a04b989b0005bf31358149a9661cb2' }, this.text);
     }
     static get style() { return lmvzChipCss(); }
     static get cmpMeta() { return {
@@ -6036,8 +6016,6 @@ class LmvzChip {
     }; }
 }
 
-const logoSvg = 'data:image/svg+xml;base64,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';
-
 class ListKeyboardNavigationController {
     host;
     elements = [];
@@ -6084,6 +6062,8 @@ class ListKeyboardNavigationController {
     }
 }
 
+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-8-28, 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-8-16, 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 {
@@ -6168,7 +6148,7 @@ class LmvzHeader extends ReactiveControllerHost {
         }
     }
     render() {
-        return (hAsync(Host, { key: '35883b5d4a92d10b5b010d822fb2233604464f9b', onFocus: this.delegateFocus.bind(this) }, hAsync("div", { key: '6fdec3af75bab2b076651b8cfef4aec8e23326a6', class: "brand" }, hAsync("slot", { key: '3127b4223b8bebfe425efc7ce45626f37fbf76b9', name: "brand" }, hAsync("img", { key: '20b3dd598e320c6950fb08bbd55dd80c47552eaf', id: "fallback-logo-lmvz", src: logoSvg, alt: "Lehrmittelverlag Z\u00FCrich" }))), hAsync("nav", { key: 'c3bf07f78930085c1a7b89421506bcd41d139911', "aria-label": "Hauptnavigation" }, hAsync("div", { key: 'fbc5199080f52da4f10c8c14fbbc0877ecc5f31c', role: "menubar", class: "primary-menubar" }, hAsync("slot", { key: '4210d213dcf7a1a27a73f2a9cf7ff97fec62f0db', name: "nav-primary", ref: (el) => (this.primarySlot = el) }), hAsync("div", { key: '7b91c269f75e1245f75d471ec5bb7eeabfe1094d', role: "menu", id: "nav-secondary", class: "secondary-menubar", hidden: !this.lmvzActiveNav, ref: (el) => (this.secondaryNav = el) }, hAsync("slot", { key: 'e23eb0f222b49d912bb45870df6d9b0d01f43788', name: this.secondarySlotName, ref: (el) => (this.secondarySlot = el) })))), hAsync("div", { key: '4b19026d5b2e54aa7aed072ce57de4acaa75cb4f', class: "actions" }, hAsync("slot", { key: '8f02d5d178bb60b40604fcd1be74d373d89c911f', name: "actions" }))));
+        return (hAsync(Host, { key: '58cf99b555112f6209b6d16047bda2cc0bbf5cde', onFocus: this.delegateFocus.bind(this) }, hAsync("div", { key: 'd9bda5c2a6b9abd6e5ea849fb31a0543c8c36bb7', class: "brand" }, hAsync("slot", { key: 'e1c2c2a0bd69875ecd46ef9f7406ccb52409b570', name: "brand" }, hAsync("img", { key: '8dfca875ffc837f2c413527ea106d640a9b9bb97', id: "fallback-logo-lmvz", src: logoSvg, alt: "Lehrmittelverlag Z\u00FCrich" }))), hAsync("nav", { key: '24ceb7f3ef54399ecb9b7b78418d3be9bb547f60', "aria-label": "Hauptnavigation" }, hAsync("div", { key: 'c9fb6b1850330493e0a26bf20ea04013725025f6', role: "menubar", class: "primary-menubar" }, hAsync("slot", { key: '19640032a28d0a9bd7f5396f7c1acd477135f864', name: "nav-primary", ref: (el) => (this.primarySlot = el) }), hAsync("div", { key: 'c11f19e15c0fea300a771060e2e4c77cce76c20f', role: "menu", id: "nav-secondary", class: "secondary-menubar", hidden: !this.lmvzActiveNav, ref: (el) => (this.secondaryNav = el) }, hAsync("slot", { key: '2df2cf852595a78391bcd7c3dd8b8d6db3847aaa', name: this.secondarySlotName, ref: (el) => (this.secondarySlot = el) })))), hAsync("div", { key: 'c256862d4f5ea38c120218372d9ad73ae19efd74', class: "actions" }, hAsync("slot", { key: '91b5eb2d9ab06005384a28cddee3d6c92afd418c', name: "actions" }))));
     }
     static get watchers() { return {
         "lmvzActiveNav": [{
@@ -6189,3812 +6169,67 @@ class LmvzHeader extends ReactiveControllerHost {
     }; }
 }
 
-/**
- * Tests if a value is a `function`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { isFunction } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- * assert.deepStrictEqual(isFunction("function"), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction$1 = input => typeof input === "function";
-/**
- * Creates a function that can be used in a data-last (aka `pipe`able) or
- * data-first style.
- *
- * The first parameter to `dual` is either the arity of the uncurried function
- * or a predicate that determines if the function is being used in a data-first
- * or data-last style.
- *
- * Using the arity is the most common use case, but there are some cases where
- * you may want to use a predicate. For example, if you have a function that
- * takes an optional argument, you can use a predicate to determine if the
- * function is being used in a data-first or data-last style.
- *
- * You can pass either the arity of the uncurried function or a predicate
- * which determines if the function is being used in a data-first or
- * data-last style.
- *
- * **Example** (Using arity to determine data-first or data-last style)
- *
- * ```ts
- * import { dual, pipe } from "effect/Function"
- *
- * const sum = dual<
- *   (that: number) => (self: number) => number,
- *   (self: number, that: number) => number
- * >(2, (self, that) => self + that)
- *
- * console.log(sum(2, 3)) // 5
- * console.log(pipe(2, sum(3))) // 5
- * ```
- *
- * **Example** (Using call signatures to define the overloads)
- *
- * ```ts
- * import { dual, pipe } from "effect/Function"
- *
- * const sum: {
- *   (that: number): (self: number) => number
- *   (self: number, that: number): number
- * } = dual(2, (self: number, that: number): number => self + that)
- *
- * console.log(sum(2, 3)) // 5
- * console.log(pipe(2, sum(3))) // 5
- * ```
- *
- * **Example** (Using a predicate to determine data-first or data-last style)
- *
- * ```ts
- * import { dual, pipe } from "effect/Function"
- *
- * const sum = dual<
- *   (that: number) => (self: number) => number,
- *   (self: number, that: number) => number
- * >(
- *   (args) => args.length === 2,
- *   (self, that) => self + that
- * )
- *
- * console.log(sum(2, 3)) // 5
- * console.log(pipe(2, sum(3))) // 5
- * ```
- *
- * @since 2.0.0
- */
-const dual = function (arity, body) {
-  if (typeof arity === "function") {
-    return function () {
-      if (arity(arguments)) {
-        // @ts-expect-error
-        return body.apply(this, arguments);
-      }
-      return self => body(self, ...arguments);
-    };
-  }
-  switch (arity) {
-    case 0:
-    case 1:
-      throw new RangeError(`Invalid arity ${arity}`);
-    case 2:
-      return function (a, b) {
-        if (arguments.length >= 2) {
-          return body(a, b);
-        }
-        return function (self) {
-          return body(self, a);
-        };
-      };
-    case 3:
-      return function (a, b, c) {
-        if (arguments.length >= 3) {
-          return body(a, b, c);
-        }
-        return function (self) {
-          return body(self, a, b);
-        };
-      };
-    case 4:
-      return function (a, b, c, d) {
-        if (arguments.length >= 4) {
-          return body(a, b, c, d);
-        }
-        return function (self) {
-          return body(self, a, b, c);
-        };
-      };
-    case 5:
-      return function (a, b, c, d, e) {
-        if (arguments.length >= 5) {
-          return body(a, b, c, d, e);
+const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));display:inline-block;line-height:0;svg{display:block}svg path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));height:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem))}}[size='sm'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.84rem + 0.13vw, 1rem));height:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.84rem + 0.13vw, 1rem))}}[size='md'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));height:var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem))}}[size='lg'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.44rem + 0.26vw, 1.75rem));height:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.44rem + 0.26vw, 1.75rem))}}[size='inherit'].sc-lmvz-icon-h{svg{width:inherit;height: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();
         }
-        return function (self) {
-          return body(self, a, b, c, d);
-        };
-      };
-    default:
-      return function () {
-        if (arguments.length >= arity) {
-          // @ts-expect-error
-          return body.apply(this, arguments);
-        }
-        const args = arguments;
-        return function (self) {
-          return body(self, ...args);
-        };
-      };
-  }
-};
-/**
- * The identity function, i.e. A function that returns its input argument.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { identity } from "effect/Function"
- *
- * assert.deepStrictEqual(identity(5), 5)
- * ```
- *
- * @since 2.0.0
- */
-const identity = a => a;
-/**
- * Creates a constant value that never changes.
- *
- * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
- * and want that inner function to always use the same value, no matter how many times it is called.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { constant } from "effect/Function"
- *
- * const constNull = constant(null)
- *
- * assert.deepStrictEqual(constNull(), null)
- * assert.deepStrictEqual(constNull(), null)
- * ```
- *
- * @since 2.0.0
- */
-const constant = value => () => value;
-/**
- * A thunk that returns always `true`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { constTrue } from "effect/Function"
- *
- * assert.deepStrictEqual(constTrue(), true)
- * ```
- *
- * @since 2.0.0
- */
-const constTrue = /*#__PURE__*/constant(true);
-/**
- * A thunk that returns always `false`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { constFalse } from "effect/Function"
- *
- * assert.deepStrictEqual(constFalse(), false)
- * ```
- *
- * @since 2.0.0
- */
-const constFalse = /*#__PURE__*/constant(false);
-/**
- * A thunk that returns always `undefined`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { constUndefined } from "effect/Function"
- *
- * assert.deepStrictEqual(constUndefined(), undefined)
- * ```
- *
- * @since 2.0.0
- */
-const constUndefined = /*#__PURE__*/constant(undefined);
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
-  switch (arguments.length) {
-    case 1:
-      return a;
-    case 2:
-      return ab(a);
-    case 3:
-      return bc(ab(a));
-    case 4:
-      return cd(bc(ab(a)));
-    case 5:
-      return de(cd(bc(ab(a))));
-    case 6:
-      return ef(de(cd(bc(ab(a)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default:
-      {
-        let ret = arguments[0];
-        for (let i = 1; i < arguments.length; i++) {
-          ret = arguments[i](ret);
+        this.intersectionObserver = undefined;
+        super.disconnectedCallback();
+    }
+    async loadIconPathData() {
+        {
+            return;
         }
-        return ret;
-      }
-  }
-}
-
-/**
- * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
- * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
- * These properties are also known in mathematics as an "equivalence relation".
- *
- * @since 2.0.0
- */
-/**
- * @category constructors
- * @since 2.0.0
- */
-const make$2 = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
-
-/**
- * The `GlobalValue` module ensures that a single instance of a value is created globally,
- * even when modules are imported multiple times (e.g., due to mixing CommonJS and ESM builds)
- * or during hot-reloading in development environments like Next.js or Remix.
- *
- * It achieves this by using a versioned global store, identified by a unique `Symbol` tied to
- * the current version of the `effect` library. The store holds values that are keyed by an identifier,
- * allowing the reuse of previously computed instances across imports or reloads.
- *
- * This pattern is particularly useful in scenarios where frequent reloading can cause services or
- * single-instance objects to be recreated unnecessarily, such as in development environments with hot-reloading.
- *
- * @since 2.0.0
- */
-const globalStoreId = `effect/GlobalValue`;
-let globalStore;
-/**
- * Retrieves or computes a global value associated with the given `id`. If the value for this `id`
- * has already been computed, it will be returned from the global store. If it does not exist yet,
- * the provided `compute` function will be executed to compute the value, store it, and then return it.
- *
- * This ensures that even in cases where the module is imported multiple times (e.g., in mixed environments
- * like CommonJS and ESM, or during hot-reloading in development), the value is computed only once and reused
- * thereafter.
- *
- * @example
- * ```ts
- * import { globalValue } from "effect/GlobalValue"
- *
- * // This cache will persist as long as the module is running,
- * // even if reloaded or imported elsewhere
- * const myCache = globalValue(
- *   Symbol.for("myCache"),
- *   () => new WeakMap<object, number>()
- * )
- * ```
- *
- * @since 2.0.0
- */
-const globalValue = (id, compute) => {
-  if (!globalStore) {
-    // @ts-expect-error
-    globalThis[globalStoreId] ??= new Map();
-    // @ts-expect-error
-    globalStore = globalThis[globalStoreId];
-  }
-  if (!globalStore.has(id)) {
-    globalStore.set(id, compute());
-  }
-  return globalStore.get(id);
-};
-
-/**
- * This module provides a collection of functions for working with predicates and refinements.
- *
- * A `Predicate<A>` is a function that takes a value of type `A` and returns a boolean.
- * It is used to check if a value satisfies a certain condition.
- *
- * A `Refinement<A, B>` is a special type of predicate that not only checks a condition
- * but also provides a type guard, allowing TypeScript to narrow the type of the input
- * value from `A` to a more specific type `B` within a conditional block.
- *
- * The module includes:
- * - Basic predicates and refinements for common types (e.g., `isString`, `isNumber`).
- * - Combinators to create new predicates from existing ones (e.g., `and`, `or`, `not`).
- * - Advanced combinators for working with data structures (e.g., `tuple`, `struct`).
- * - Type-level utilities for inspecting predicate and refinement types.
- *
- * @since 2.0.0
- */
-/**
- * A refinement that checks if a value is a `Function`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { isFunction } from "effect/Predicate"
- *
- * assert.strictEqual(isFunction(() => {}), true)
- * assert.strictEqual(isFunction(isFunction), true)
- *
- * assert.strictEqual(isFunction("function"), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction = isFunction$1;
-/**
- * Checks if the input is an object or an array.
- * @internal
- */
-const isRecordOrArray = input => typeof input === "object" && input !== null;
-/**
- * A refinement that checks if a value is an `object`. Note that in JavaScript,
- * arrays and functions are also considered objects.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { isObject } from "effect/Predicate"
- *
- * assert.strictEqual(isObject({}), true)
- * assert.strictEqual(isObject([]), true)
- * assert.strictEqual(isObject(() => {}), true)
- *
- * assert.strictEqual(isObject(null), false)
- * assert.strictEqual(isObject("hello"), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- * @see isRecord to check for plain objects (excluding arrays and functions).
- */
-const isObject = input => isRecordOrArray(input) || isFunction(input);
-/**
- * A refinement that checks if a value is an object-like value and has a specific property key.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { hasProperty } from "effect/Predicate"
- *
- * assert.strictEqual(hasProperty({ a: 1 }, "a"), true)
- * assert.strictEqual(hasProperty({ a: 1 }, "b"), false)
- *
- * const value: unknown = { name: "Alice" };
- * if (hasProperty(value, "name")) {
- *   // The type of `value` is narrowed to `{ name: unknown }`
- *   // and we can safely access `value.name`
- *   console.log(value.name)
- * }
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-const hasProperty = /*#__PURE__*/dual(2, (self, property) => isObject(self) && property in self);
-/**
- * A refinement that checks if a value is an object with a `_tag` property
- * that matches the given tag. This is a powerful tool for working with
- * discriminated union types.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { isTagged } from "effect/Predicate"
- *
- * type Shape = { _tag: "circle"; radius: number } | { _tag: "square"; side: number }
- *
- * const isCircle = isTagged("circle")
- *
- * const shape1: Shape = { _tag: "circle", radius: 10 }
- * const shape2: Shape = { _tag: "square", side: 5 }
- *
- * assert.strictEqual(isCircle(shape1), true)
- * assert.strictEqual(isCircle(shape2), false)
- *
- * if (isCircle(shape1)) {
- *   // shape1 is now narrowed to { _tag: "circle"; radius: number }
- *   assert.strictEqual(shape1.radius, 10)
- * }
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-const isTagged = /*#__PURE__*/dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
-
-/**
- * @since 2.0.0
- */
-/** @internal */
-const getBugErrorMessage = message => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
-
-/**
- * @since 2.0.0
- */
-/**
- * @category constructors
- * @since 2.0.0
- */
-let SingleShotGen$1 = class SingleShotGen {
-  self;
-  called = false;
-  constructor(self) {
-    this.self = self;
-  }
-  /**
-   * @since 2.0.0
-   */
-  next(a) {
-    return this.called ? {
-      value: a,
-      done: true
-    } : (this.called = true, {
-      value: this.self,
-      done: false
-    });
-  }
-  /**
-   * @since 2.0.0
-   */
-  return(a) {
-    return {
-      value: a,
-      done: true
-    };
-  }
-  /**
-   * @since 2.0.0
-   */
-  throw(e) {
-    throw e;
-  }
-  /**
-   * @since 2.0.0
-   */
-  [Symbol.iterator]() {
-    return new SingleShotGen(this.self);
-  }
-};
-/**
- * @since 3.0.6
- */
-const YieldWrapTypeId = /*#__PURE__*/Symbol.for("effect/Utils/YieldWrap");
-/**
- * @since 3.0.6
- */
-class YieldWrap {
-  /**
-   * @since 3.0.6
-   */
-  #value;
-  constructor(value) {
-    this.#value = value;
-  }
-  /**
-   * @since 3.0.6
-   */
-  [YieldWrapTypeId]() {
-    return this.#value;
-  }
-}
-/**
- * Note: this is an experimental feature made available to allow custom matchers in tests, not to be directly used yet in user code
- *
- * @since 3.1.1
- * @status experimental
- * @category modifiers
- */
-const structuralRegionState = /*#__PURE__*/globalValue("effect/Utils/isStructuralRegion", () => ({
-  enabled: false,
-  tester: undefined
-}));
-
-/**
- * @since 2.0.0
- */
-/** @internal */
-const randomHashCache = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Hash/randomHashCache"), () => new WeakMap());
-/**
- * @since 2.0.0
- * @category symbols
- */
-const symbol$1 = /*#__PURE__*/Symbol.for("effect/Hash");
-/**
- * @since 2.0.0
- * @category hashing
- */
-const hash = self => {
-  if (structuralRegionState.enabled === true) {
-    return 0;
-  }
-  switch (typeof self) {
-    case "number":
-      return number(self);
-    case "bigint":
-      return string(self.toString(10));
-    case "boolean":
-      return string(String(self));
-    case "symbol":
-      return string(String(self));
-    case "string":
-      return string(self);
-    case "undefined":
-      return string("undefined");
-    case "function":
-    case "object":
-      {
-        if (self === null) {
-          return string("null");
-        } else if (self instanceof Date) {
-          if (Number.isNaN(self.getTime())) {
-            return string("Invalid Date");
-          }
-          return hash(self.toISOString());
-        } else if (self instanceof URL) {
-          return hash(self.href);
-        } else if (isHash(self)) {
-          return self[symbol$1]();
-        } else {
-          return random(self);
+    }
+    componentDidRender() {
+        this.validationEl = this.el.querySelector('svg');
+        this.ariaValidationController.revalidateAria();
+        super.componentDidRender();
+    }
+    render() {
+        return hAsync(Host, { key: 'b36586af32709b492336fe4ec1fe1fe1fe7a9e4b', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
+    }
+    waitUntilVisible(callback, rootMargin = 50) {
+        {
+            callback();
+            return;
         }
-      }
-    default:
-      throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
-  }
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const random = self => {
-  if (!randomHashCache.has(self)) {
-    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
-  }
-  return randomHashCache.get(self);
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const combine = b => self => self * 53 ^ b;
-/**
- * @since 2.0.0
- * @category hashing
- */
-const optimize = n => n & 0xbfffffff | n >>> 1 & 0x40000000;
-/**
- * @since 2.0.0
- * @category guards
- */
-const isHash = u => hasProperty(u, symbol$1);
-/**
- * @since 2.0.0
- * @category hashing
- */
-const number = n => {
-  if (n !== n || n === Infinity) {
-    return 0;
-  }
-  let h = n | 0;
-  if (h !== n) {
-    h ^= n * 0xffffffff;
-  }
-  while (n > 0xffffffff) {
-    h ^= n /= 0xffffffff;
-  }
-  return optimize(h);
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const string = str => {
-  let h = 5381,
-    i = str.length;
-  while (i) {
-    h = h * 33 ^ str.charCodeAt(--i);
-  }
-  return optimize(h);
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const structureKeys = (o, keys) => {
-  let h = 12289;
-  for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]), combine(hash(o[keys[i]])));
-  }
-  return optimize(h);
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const structure = o => structureKeys(o, Object.keys(o));
-/**
- * @since 2.0.0
- * @category hashing
- */
-const array = arr => {
-  let h = 6151;
-  for (let i = 0; i < arr.length; i++) {
-    h = pipe(h, combine(hash(arr[i])));
-  }
-  return optimize(h);
-};
-/**
- * @since 2.0.0
- * @category hashing
- */
-const cached = function () {
-  if (arguments.length === 1) {
-    const self = arguments[0];
-    return function (hash) {
-      Object.defineProperty(self, symbol$1, {
-        value() {
-          return hash;
-        },
-        enumerable: false
-      });
-      return hash;
-    };
-  }
-  const self = arguments[0];
-  const hash = arguments[1];
-  Object.defineProperty(self, symbol$1, {
-    value() {
-      return hash;
-    },
-    enumerable: false
-  });
-  return hash;
-};
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-const symbol = /*#__PURE__*/Symbol.for("effect/Equal");
-function equals() {
-  if (arguments.length === 1) {
-    return self => compareBoth(self, arguments[0]);
-  }
-  return compareBoth(arguments[0], arguments[1]);
-}
-function compareBoth(self, that) {
-  if (self === that) {
-    return true;
-  }
-  const selfType = typeof self;
-  if (selfType !== typeof that) {
-    return false;
-  }
-  if (selfType === "object" || selfType === "function") {
-    if (self !== null && that !== null) {
-      if (isEqual(self) && isEqual(that)) {
-        if (hash(self) === hash(that) && self[symbol](that)) {
-          return true;
-        } else {
-          return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-        }
-      } else if (self instanceof Date && that instanceof Date) {
-        const t1 = self.getTime();
-        const t2 = that.getTime();
-        return t1 === t2 || Number.isNaN(t1) && Number.isNaN(t2);
-      } else if (self instanceof URL && that instanceof URL) {
-        return self.href === that.href;
-      }
-    }
-    if (structuralRegionState.enabled) {
-      if (self === null || that === null) {
-        return false;
-      }
-      if (Array.isArray(self) && Array.isArray(that)) {
-        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
-      }
-      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(that) === Object.prototype) {
-        const keysSelf = Object.keys(self);
-        const keysThat = Object.keys(that);
-        if (keysSelf.length === keysThat.length) {
-          for (const key of keysSelf) {
-            // @ts-expect-error
-            if (!(key in that && compareBoth(self[key], that[key]))) {
-              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-            }
-          }
-          return true;
-        }
-      }
-      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-    }
-  }
-  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-}
-/**
- * @since 2.0.0
- * @category guards
- */
-const isEqual = u => hasProperty(u, symbol);
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-const NodeInspectSymbol = /*#__PURE__*/Symbol.for("nodejs.util.inspect.custom");
-/**
- * @since 2.0.0
- */
-const toJSON = x => {
-  try {
-    if (hasProperty(x, "toJSON") && isFunction(x["toJSON"]) && x["toJSON"].length === 0) {
-      return x.toJSON();
-    } else if (Array.isArray(x)) {
-      return x.map(toJSON);
-    }
-  } catch {
-    return {};
-  }
-  return redact(x);
-};
-/**
- * @since 2.0.0
- */
-const format = x => JSON.stringify(x, null, 2);
-/**
- * @since 2.0.0
- */
-const stringifyCircular = (obj, whitespace) => {
-  let cache = [];
-  const retVal = JSON.stringify(obj, (_key, value) => typeof value === "object" && value !== null ? cache.includes(value) ? undefined // circular reference
-  : cache.push(value) && (redactableState.fiberRefs !== undefined && isRedactable(value) ? value[symbolRedactable](redactableState.fiberRefs) : value) : value, whitespace);
-  cache = undefined;
-  return retVal;
-};
-/**
- * @since 3.10.0
- * @category redactable
- */
-const symbolRedactable = /*#__PURE__*/Symbol.for("effect/Inspectable/Redactable");
-/**
- * @since 3.10.0
- * @category redactable
- */
-const isRedactable = u => typeof u === "object" && u !== null && symbolRedactable in u;
-const redactableState = /*#__PURE__*/globalValue("effect/Inspectable/redactableState", () => ({
-  fiberRefs: undefined
-}));
-/**
- * @since 3.10.0
- * @category redactable
- */
-const redact = u => {
-  if (isRedactable(u) && redactableState.fiberRefs !== undefined) {
-    return u[symbolRedactable](redactableState.fiberRefs);
-  }
-  return u;
-};
-
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- */
-const pipeArguments = (self, args) => {
-  switch (args.length) {
-    case 0:
-      return self;
-    case 1:
-      return args[0](self);
-    case 2:
-      return args[1](args[0](self));
-    case 3:
-      return args[2](args[1](args[0](self)));
-    case 4:
-      return args[3](args[2](args[1](args[0](self))));
-    case 5:
-      return args[4](args[3](args[2](args[1](args[0](self)))));
-    case 6:
-      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
-    case 7:
-      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
-    case 8:
-      return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
-    case 9:
-      return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
-    default:
-      {
-        let ret = self;
-        for (let i = 0, len = args.length; i < len; i++) {
-          ret = args[i](ret);
-        }
-        return ret;
-      }
-  }
-};
-
-/** @internal */
-/** @internal */
-const OP_COMMIT = "Commit";
-/** @internal */
-const OP_FAILURE = "Failure";
-/** @internal */
-const OP_WITH_RUNTIME = "WithRuntime";
-
-let moduleVersion = "3.21.1";
-const getCurrentVersion = () => moduleVersion;
-
-/** @internal */
-const EffectTypeId$1 = /*#__PURE__*/Symbol.for("effect/Effect");
-/** @internal */
-const StreamTypeId = /*#__PURE__*/Symbol.for("effect/Stream");
-/** @internal */
-const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
-/** @internal */
-const ChannelTypeId = /*#__PURE__*/Symbol.for("effect/Channel");
-/** @internal */
-const effectVariance = {
-  /* c8 ignore next */
-  _R: _ => _,
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _A: _ => _,
-  _V: /*#__PURE__*/getCurrentVersion()
-};
-const sinkVariance = {
-  /* c8 ignore next */
-  _A: _ => _,
-  /* c8 ignore next */
-  _In: _ => _,
-  /* c8 ignore next */
-  _L: _ => _,
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _R: _ => _
-};
-const channelVariance = {
-  /* c8 ignore next */
-  _Env: _ => _,
-  /* c8 ignore next */
-  _InErr: _ => _,
-  /* c8 ignore next */
-  _InElem: _ => _,
-  /* c8 ignore next */
-  _InDone: _ => _,
-  /* c8 ignore next */
-  _OutErr: _ => _,
-  /* c8 ignore next */
-  _OutElem: _ => _,
-  /* c8 ignore next */
-  _OutDone: _ => _
-};
-/** @internal */
-const EffectPrototype = {
-  [EffectTypeId$1]: effectVariance,
-  [StreamTypeId]: effectVariance,
-  [SinkTypeId]: sinkVariance,
-  [ChannelTypeId]: channelVariance,
-  [symbol](that) {
-    return this === that;
-  },
-  [symbol$1]() {
-    return cached(this, random(this));
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen$1(new YieldWrap(this));
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const StructuralPrototype = {
-  [symbol$1]() {
-    return cached(this, structure(this));
-  },
-  [symbol](that) {
-    const selfKeys = Object.keys(this);
-    const thatKeys = Object.keys(that);
-    if (selfKeys.length !== thatKeys.length) {
-      return false;
-    }
-    for (const key of selfKeys) {
-      if (!(key in that && equals(this[key], that[key]))) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-/** @internal */
-const CommitPrototype = {
-  ...EffectPrototype,
-  _op: OP_COMMIT
-};
-/** @internal */
-const StructuralCommitPrototype = {
-  ...CommitPrototype,
-  ...StructuralPrototype
-};
-
-/**
- * @since 2.0.0
- */
-const TypeId$2 = /*#__PURE__*/Symbol.for("effect/Option");
-const CommonProto$1 = {
-  ...EffectPrototype,
-  [TypeId$2]: {
-    _A: _ => _
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  toString() {
-    return format(this.toJSON());
-  }
-};
-const SomeProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto$1), {
-  _tag: "Some",
-  _op: "Some",
-  [symbol](that) {
-    return isOption(that) && isSome$1(that) && equals(this.value, that.value);
-  },
-  [symbol$1]() {
-    return cached(this, combine(hash(this._tag))(hash(this.value)));
-  },
-  toJSON() {
-    return {
-      _id: "Option",
-      _tag: this._tag,
-      value: toJSON(this.value)
-    };
-  }
-});
-const NoneHash = /*#__PURE__*/hash("None");
-const NoneProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto$1), {
-  _tag: "None",
-  _op: "None",
-  [symbol](that) {
-    return isOption(that) && isNone$1(that);
-  },
-  [symbol$1]() {
-    return NoneHash;
-  },
-  toJSON() {
-    return {
-      _id: "Option",
-      _tag: this._tag
-    };
-  }
-});
-/** @internal */
-const isOption = input => hasProperty(input, TypeId$2);
-/** @internal */
-const isNone$1 = fa => fa._tag === "None";
-/** @internal */
-const isSome$1 = fa => fa._tag === "Some";
-/** @internal */
-const none$1 = /*#__PURE__*/Object.create(NoneProto);
-/** @internal */
-const some$1 = value => {
-  const a = Object.create(SomeProto);
-  a.value = value;
-  return a;
-};
-
-/**
- * @since 2.0.0
- */
-/**
- * @internal
- */
-const TypeId$1 = /*#__PURE__*/Symbol.for("effect/Either");
-const CommonProto = {
-  ...EffectPrototype,
-  [TypeId$1]: {
-    _R: _ => _
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  toString() {
-    return format(this.toJSON());
-  }
-};
-const RightProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {
-  _tag: "Right",
-  _op: "Right",
-  [symbol](that) {
-    return isEither(that) && isRight$1(that) && equals(this.right, that.right);
-  },
-  [symbol$1]() {
-    return combine(hash(this._tag))(hash(this.right));
-  },
-  toJSON() {
-    return {
-      _id: "Either",
-      _tag: this._tag,
-      right: toJSON(this.right)
-    };
-  }
-});
-const LeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {
-  _tag: "Left",
-  _op: "Left",
-  [symbol](that) {
-    return isEither(that) && isLeft(that) && equals(this.left, that.left);
-  },
-  [symbol$1]() {
-    return combine(hash(this._tag))(hash(this.left));
-  },
-  toJSON() {
-    return {
-      _id: "Either",
-      _tag: this._tag,
-      left: toJSON(this.left)
-    };
-  }
-});
-/** @internal */
-const isEither = input => hasProperty(input, TypeId$1);
-/** @internal */
-const isLeft = ma => ma._tag === "Left";
-/** @internal */
-const isRight$1 = ma => ma._tag === "Right";
-/** @internal */
-const left$1 = left => {
-  const a = Object.create(LeftProto);
-  a.left = left;
-  return a;
-};
-/** @internal */
-const right$1 = right => {
-  const a = Object.create(RightProto);
-  a.right = right;
-  return a;
-};
-/** @internal */
-const getRight$1 = self => isLeft(self) ? none$1 : some$1(self.right);
-
-/**
- * @since 2.0.0
- */
-/**
- * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias
- * of this structure.
- *
- * @category constructors
- * @since 2.0.0
- */
-const right = right$1;
-/**
- * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this
- * structure.
- *
- * @category constructors
- * @since 2.0.0
- */
-const left = left$1;
-/**
- * Determine if a `Either` is a `Right`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Either } from "effect"
- *
- * assert.deepStrictEqual(Either.isRight(Either.right(1)), true)
- * assert.deepStrictEqual(Either.isRight(Either.left("a")), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-const isRight = isRight$1;
-/**
- * Extracts the value of an `Either` or throws if the `Either` is `Left`.
- *
- * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Either } from "effect"
- *
- * assert.deepStrictEqual(
- *   Either.getOrThrowWith(Either.right(1), () => new Error('Unexpected Left')),
- *   1
- * )
- * assert.throws(() => Either.getOrThrowWith(Either.left("error"), () => new Error('Unexpected Left')))
- * ```
- *
- * @category getters
- * @since 2.0.0
- */
-const getOrThrowWith = /*#__PURE__*/dual(2, (self, onLeft) => {
-  if (isRight(self)) {
-    return self.right;
-  }
-  throw onLeft(self.left);
-});
-
-/**
- * Represents the absence of a value by creating an empty `Option`.
- *
- * `Option.none` returns an `Option<never>`, which is a subtype of `Option<A>`.
- * This means you can use it in place of any `Option<A>` regardless of the type
- * `A`.
- *
- * **Example** (Creating an Option with No Value)
- *
- * ```ts
- * import { Option } from "effect"
- *
- * // An Option holding no value
- * //
- * //      ┌─── Option<never>
- * //      ▼
- * const noValue = Option.none()
- *
- * console.log(noValue)
- * // Output: { _id: 'Option', _tag: 'None' }
- * ```
- *
- * @see {@link some} for the opposite operation.
- *
- * @category Constructors
- * @since 2.0.0
- */
-const none = () => none$1;
-/**
- * Wraps the given value into an `Option` to represent its presence.
- *
- * **Example** (Creating an Option with a Value)
- *
- * ```ts
- * import { Option } from "effect"
- *
- * // An Option holding the number 1
- * //
- * //      ┌─── Option<number>
- * //      ▼
- * const value = Option.some(1)
- *
- * console.log(value)
- * // Output: { _id: 'Option', _tag: 'Some', value: 1 }
- * ```
- *
- * @see {@link none} for the opposite operation.
- *
- * @category Constructors
- * @since 2.0.0
- */
-const some = some$1;
-/**
- * Checks whether an `Option` represents the absence of a value (`None`).
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- *
- * console.log(Option.isNone(Option.some(1)))
- * // Output: false
- *
- * console.log(Option.isNone(Option.none()))
- * // Output: true
- * ```
- *
- * @see {@link isSome} for the opposite check.
- *
- * @category Guards
- * @since 2.0.0
- */
-const isNone = isNone$1;
-/**
- * Checks whether an `Option` contains a value (`Some`).
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- *
- * console.log(Option.isSome(Option.some(1)))
- * // Output: true
- *
- * console.log(Option.isSome(Option.none()))
- * // Output: false
- * ```
- *
- * @see {@link isNone} for the opposite check.
- *
- * @category Guards
- * @since 2.0.0
- */
-const isSome = isSome$1;
-/**
- * Performs pattern matching on an `Option` to handle both `Some` and `None`
- * cases.
- *
- * **Details**
- *
- * This function allows you to match against an `Option` and handle both
- * scenarios: when the `Option` is `None` (i.e., contains no value), and when
- * the `Option` is `Some` (i.e., contains a value). It executes one of the
- * provided functions based on the case:
- *
- * - If the `Option` is `None`, the `onNone` function is executed and its result
- *   is returned.
- * - If the `Option` is `Some`, the `onSome` function is executed with the
- *   contained value, and its result is returned.
- *
- * This function provides a concise and functional way to handle optional values
- * without resorting to `if` or manual checks, making your code more declarative
- * and readable.
- *
- * **Example** (Pattern Matching with Option)
- *
- * ```ts
- * import { Option } from "effect"
- *
- * const foo = Option.some(1)
- *
- * const message = Option.match(foo, {
- *   onNone: () => "Option is empty",
- *   onSome: (value) => `Option has a value: ${value}`
- * })
- *
- * console.log(message)
- * // Output: "Option has a value: 1"
- * ```
- *
- * @category Pattern matching
- * @since 2.0.0
- */
-const match = /*#__PURE__*/dual(2, (self, {
-  onNone,
-  onSome
-}) => isNone(self) ? onNone() : onSome(self.value));
-/**
- * Converts an `Either` into an `Option` by discarding the error and extracting
- * the right value.
- *
- * **Details**
- *
- * This function takes an `Either` and returns an `Option` based on its value:
- *
- * - If the `Either` is a `Right`, its value is wrapped in a `Some` and
- *   returned.
- * - If the `Either` is a `Left`, the error is discarded, and `None` is
- *   returned.
- *
- * This is particularly useful when you only care about the success case
- * (`Right`) of an `Either` and want to handle the result using `Option`. By
- * using this function, you can convert `Either` into a simpler structure for
- * cases where error handling is not required.
- *
- * @example
- * ```ts
- * import { Either, Option } from "effect"
- *
- * console.log(Option.getRight(Either.right("ok")))
- * // Output: { _id: 'Option', _tag: 'Some', value: 'ok' }
- *
- * console.log(Option.getRight(Either.left("err")))
- * // Output: { _id: 'Option', _tag: 'None' }
- * ```
- *
- * @see {@link getLeft} for the opposite operation.
- *
- * @category Conversions
- * @since 2.0.0
- */
-const getRight = getRight$1;
-/**
- * Returns the value contained in the `Option` if it is `Some`, otherwise
- * evaluates and returns the result of `onNone`.
- *
- * **Details**
- *
- * This function allows you to provide a fallback value or computation for when
- * an `Option` is `None`. If the `Option` contains a value (`Some`), that value
- * is returned. If it is empty (`None`), the `onNone` function is executed, and
- * its result is returned instead.
- *
- * This utility is helpful for safely handling `Option` values by ensuring you
- * always receive a meaningful result, whether or not the `Option` contains a
- * value. It is particularly useful for providing default values or alternative
- * logic when working with optional values.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- *
- * console.log(Option.some(1).pipe(Option.getOrElse(() => 0)))
- * // Output: 1
- *
- * console.log(Option.none().pipe(Option.getOrElse(() => 0)))
- * // Output: 0
- * ```
- *
- * @see {@link getOrNull} for a version that returns `null` instead of executing a function.
- * @see {@link getOrUndefined} for a version that returns `undefined` instead of executing a function.
- *
- * @category Getters
- * @since 2.0.0
- */
-const getOrElse = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);
-/**
- * Returns the value contained in the `Option` if it is `Some`; otherwise,
- * returns `undefined`.
- *
- * **Details**
- *
- * This function provides a way to extract the value of an `Option` while
- * falling back to `undefined` if the `Option` is `None`.
- *
- * It is particularly useful in scenarios where `undefined` is an acceptable
- * placeholder for the absence of a value, such as when interacting with APIs or
- * systems that use `undefined` as a default for missing values.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- *
- * console.log(Option.getOrUndefined(Option.some(1)))
- * // Output: 1
- *
- * console.log(Option.getOrUndefined(Option.none()))
- * // Output: undefined
- * ```
- *
- * @category Getters
- * @since 2.0.0
- */
-const getOrUndefined = /*#__PURE__*/getOrElse(constUndefined);
-
-/**
- * This module provides utility functions for working with arrays in TypeScript.
- *
- * @since 2.0.0
- */
-/**
- * Creates a new `Array` from an iterable collection of values.
- * If the input is already an array, it returns the input as-is.
- * Otherwise, it converts the iterable collection to an array.
- *
- * **Example**
- *
- * ```ts
- * import { Array } from "effect"
- *
- * const result = Array.fromIterable(new Set([1, 2, 3]))
- * console.log(result) // [1, 2, 3]
- * ```
- *
- * @category constructors
- * @since 2.0.0
- */
-const fromIterable = collection => Array.isArray(collection) ? collection : Array.from(collection);
-/**
- * Reverse an `Iterable`, creating a new `Array`.
- *
- * **Example**
- *
- * ```ts
- * import { Array } from "effect"
- *
- * const result = Array.reverse([1, 2, 3, 4])
- * console.log(result) // [4, 3, 2, 1]
- * ```
- *
- * @category elements
- * @since 2.0.0
- */
-const reverse$1 = self => Array.from(self).reverse();
-/**
- * Reduces an array from the left.
- *
- * **Example**
- *
- * ```ts
- * import { Array } from "effect"
- *
- * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n)
- * console.log(result) // 6
- * ```
- *
- * @category folding
- * @since 2.0.0
- */
-const reduce$2 = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
-
-/**
- * This module provides types and utility functions to create and work with branded types,
- * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
- *
- * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
- * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
- *
- * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
- * This is useful when you want to distinguish between two values of the same type that have different meanings.
- * The `nominal` function does not perform any validation of the input data.
- *
- * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
- * but with a different name, and it also allows for validation of the input data.
- * The `refined` function takes a predicate that is used to validate the input data.
- * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
- *
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
-/**
- * Returns a `BrandErrors` that contains a single `RefinementError`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const error = (message, meta) => [{
-  message,
-  meta
-}];
-function refined(...args) {
-  const either = args.length === 2 ? unbranded => args[0](unbranded) ? right(unbranded) : left(args[1](unbranded)) : unbranded => {
-    return match(args[0](unbranded), {
-      onNone: () => right(unbranded),
-      onSome: left
-    });
-  };
-  return Object.assign(unbranded => getOrThrowWith(either(unbranded), identity), {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => getRight(either(args)),
-    either,
-    is: args => isRight(either(args))
-  });
-}
-
-/**
- * @since 2.0.0
- */
-const TypeId = /*#__PURE__*/Symbol.for("effect/Chunk");
-function copy(src, srcPos, dest, destPos, len) {
-  for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
-    dest[destPos + i - srcPos] = src[i];
-  }
-  return dest;
-}
-const emptyArray = [];
-/**
- * Compares the two chunks of equal length using the specified function
- *
- * @category equivalence
- * @since 2.0.0
- */
-const getEquivalence = isEquivalent => make$2((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
-const _equivalence = /*#__PURE__*/getEquivalence(equals);
-const ChunkProto = {
-  [TypeId]: {
-    _A: _ => _
-  },
-  toString() {
-    return format(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "Chunk",
-      values: toReadonlyArray(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol](that) {
-    return isChunk(that) && _equivalence(this, that);
-  },
-  [symbol$1]() {
-    return cached(this, array(toReadonlyArray(this)));
-  },
-  [Symbol.iterator]() {
-    switch (this.backing._tag) {
-      case "IArray":
-        {
-          return this.backing.array[Symbol.iterator]();
-        }
-      case "IEmpty":
-        {
-          return emptyArray[Symbol.iterator]();
-        }
-      default:
-        {
-          return toReadonlyArray(this)[Symbol.iterator]();
-        }
-    }
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const makeChunk = backing => {
-  const chunk = Object.create(ChunkProto);
-  chunk.backing = backing;
-  switch (backing._tag) {
-    case "IEmpty":
-      {
-        chunk.length = 0;
-        chunk.depth = 0;
-        chunk.left = chunk;
-        chunk.right = chunk;
-        break;
-      }
-    case "IConcat":
-      {
-        chunk.length = backing.left.length + backing.right.length;
-        chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
-        chunk.left = backing.left;
-        chunk.right = backing.right;
-        break;
-      }
-    case "IArray":
-      {
-        chunk.length = backing.array.length;
-        chunk.depth = 0;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
-        break;
-      }
-    case "ISingleton":
-      {
-        chunk.length = 1;
-        chunk.depth = 0;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
-        break;
-      }
-    case "ISlice":
-      {
-        chunk.length = backing.length;
-        chunk.depth = backing.chunk.depth + 1;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
-        break;
-      }
-  }
-  return chunk;
-};
-/**
- * Checks if `u` is a `Chunk<unknown>`
- *
- * @category constructors
- * @since 2.0.0
- */
-const isChunk = u => hasProperty(u, TypeId);
-const _empty$2 = /*#__PURE__*/makeChunk({
-  _tag: "IEmpty"
-});
-/**
- * @category constructors
- * @since 2.0.0
- */
-const empty$3 = () => _empty$2;
-/**
- * Builds a `NonEmptyChunk` from an non-empty collection of elements.
- *
- * @category constructors
- * @since 2.0.0
- */
-const make$1 = (...as) => unsafeFromNonEmptyArray(as);
-/**
- * Builds a `NonEmptyChunk` from a single element.
- *
- * @category constructors
- * @since 2.0.0
- */
-const of = a => makeChunk({
-  _tag: "ISingleton",
-  a
-});
-const copyToArray = (self, array, initial) => {
-  switch (self.backing._tag) {
-    case "IArray":
-      {
-        copy(self.backing.array, 0, array, initial, self.length);
-        break;
-      }
-    case "IConcat":
-      {
-        copyToArray(self.left, array, initial);
-        copyToArray(self.right, array, initial + self.left.length);
-        break;
-      }
-    case "ISingleton":
-      {
-        array[initial] = self.backing.a;
-        break;
-      }
-    case "ISlice":
-      {
-        let i = 0;
-        let j = initial;
-        while (i < self.length) {
-          array[j] = unsafeGet(self, i);
-          i += 1;
-          j += 1;
-        }
-        break;
-      }
-  }
-};
-const toReadonlyArray_ = self => {
-  switch (self.backing._tag) {
-    case "IEmpty":
-      {
-        return emptyArray;
-      }
-    case "IArray":
-      {
-        return self.backing.array;
-      }
-    default:
-      {
-        const arr = new Array(self.length);
-        copyToArray(self, arr, 0);
-        self.backing = {
-          _tag: "IArray",
-          array: arr
-        };
-        self.left = _empty$2;
-        self.right = _empty$2;
-        self.depth = 0;
-        return arr;
-      }
-  }
-};
-/**
- * Converts a `Chunk` into a `ReadonlyArray`. If the provided `Chunk` is
- * non-empty (`NonEmptyChunk`), the function will return a
- * `NonEmptyReadonlyArray`, ensuring the non-empty property is preserved.
- *
- * @category conversions
- * @since 2.0.0
- */
-const toReadonlyArray = toReadonlyArray_;
-const reverseChunk = self => {
-  switch (self.backing._tag) {
-    case "IEmpty":
-    case "ISingleton":
-      return self;
-    case "IArray":
-      {
-        return makeChunk({
-          _tag: "IArray",
-          array: reverse$1(self.backing.array)
-        });
-      }
-    case "IConcat":
-      {
-        return makeChunk({
-          _tag: "IConcat",
-          left: reverse(self.backing.right),
-          right: reverse(self.backing.left)
-        });
-      }
-    case "ISlice":
-      return unsafeFromArray(reverse$1(toReadonlyArray(self)));
-  }
-};
-/**
- * Reverses the order of elements in a `Chunk`.
- * Importantly, if the input chunk is a `NonEmptyChunk`, the reversed chunk will also be a `NonEmptyChunk`.
- *
- * **Example**
- *
- * ```ts
- * import { Chunk } from "effect"
- *
- * const chunk = Chunk.make(1, 2, 3)
- * const result = Chunk.reverse(chunk)
- *
- * console.log(result)
- * // { _id: 'Chunk', values: [ 3, 2, 1 ] }
- * ```
- *
- * @since 2.0.0
- * @category elements
- */
-const reverse = reverseChunk;
-/**
- * Wraps an array into a chunk without copying, unsafe on mutable arrays
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeFromArray = self => self.length === 0 ? empty$3() : self.length === 1 ? of(self[0]) : makeChunk({
-  _tag: "IArray",
-  array: self
-});
-/**
- * Wraps an array into a chunk without copying, unsafe on mutable arrays
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeFromNonEmptyArray = self => unsafeFromArray(self);
-/**
- * Gets an element unsafely, will throw on out of bounds
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeGet = /*#__PURE__*/dual(2, (self, index) => {
-  switch (self.backing._tag) {
-    case "IEmpty":
-      {
-        throw new Error(`Index out of bounds`);
-      }
-    case "ISingleton":
-      {
-        if (index !== 0) {
-          throw new Error(`Index out of bounds`);
-        }
-        return self.backing.a;
-      }
-    case "IArray":
-      {
-        if (index >= self.length || index < 0) {
-          throw new Error(`Index out of bounds`);
-        }
-        return self.backing.array[index];
-      }
-    case "IConcat":
-      {
-        return index < self.left.length ? unsafeGet(self.left, index) : unsafeGet(self.right, index - self.left.length);
-      }
-    case "ISlice":
-      {
-        return unsafeGet(self.backing.chunk, index + self.backing.offset);
-      }
-  }
-});
-/**
- * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prepend = /*#__PURE__*/dual(2, (self, elem) => appendAll(of(elem), self));
-/**
- * Concatenates two chunks, combining their elements.
- * If either chunk is non-empty, the result is also a non-empty chunk.
- *
- * **Example**
- *
- * ```ts
- * import { Chunk } from "effect"
- *
- * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray)
- *
- * console.log(result)
- * // [ 1, 2, "a", "b" ]
- * ```
- *
- * @category concatenating
- * @since 2.0.0
- */
-const appendAll = /*#__PURE__*/dual(2, (self, that) => {
-  if (self.backing._tag === "IEmpty") {
-    return that;
-  }
-  if (that.backing._tag === "IEmpty") {
-    return self;
-  }
-  const diff = that.depth - self.depth;
-  if (Math.abs(diff) <= 1) {
-    return makeChunk({
-      _tag: "IConcat",
-      left: self,
-      right: that
-    });
-  } else if (diff < -1) {
-    if (self.left.depth >= self.right.depth) {
-      const nr = appendAll(self.right, that);
-      return makeChunk({
-        _tag: "IConcat",
-        left: self.left,
-        right: nr
-      });
-    } else {
-      const nrr = appendAll(self.right.right, that);
-      if (nrr.depth === self.depth - 3) {
-        const nr = makeChunk({
-          _tag: "IConcat",
-          left: self.right.left,
-          right: nrr
-        });
-        return makeChunk({
-          _tag: "IConcat",
-          left: self.left,
-          right: nr
-        });
-      } else {
-        const nl = makeChunk({
-          _tag: "IConcat",
-          left: self.left,
-          right: self.right.left
-        });
-        return makeChunk({
-          _tag: "IConcat",
-          left: nl,
-          right: nrr
-        });
-      }
-    }
-  } else {
-    if (that.right.depth >= that.left.depth) {
-      const nl = appendAll(self, that.left);
-      return makeChunk({
-        _tag: "IConcat",
-        left: nl,
-        right: that.right
-      });
-    } else {
-      const nll = appendAll(self, that.left.left);
-      if (nll.depth === that.depth - 3) {
-        const nl = makeChunk({
-          _tag: "IConcat",
-          left: nll,
-          right: that.left.right
-        });
-        return makeChunk({
-          _tag: "IConcat",
-          left: nl,
-          right: that.right
-        });
-      } else {
-        const nr = makeChunk({
-          _tag: "IConcat",
-          left: that.left.right,
-          right: that.right
-        });
-        return makeChunk({
-          _tag: "IConcat",
-          left: nll,
-          right: nr
-        });
-      }
-    }
-  }
-});
-/**
- * Determines if the chunk is empty.
- *
- * @since 2.0.0
- * @category elements
- */
-const isEmpty = self => self.length === 0;
-/**
- * Determines if the chunk is not empty.
- *
- * @since 2.0.0
- * @category elements
- */
-const isNonEmpty = self => self.length > 0;
-/**
- * Returns the first element of this chunk.
- *
- * It will throw an error if the chunk is empty.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeHead = self => unsafeGet(self, 0);
-/**
- * Returns the first element of this non empty chunk.
- *
- * @since 2.0.0
- * @category elements
- */
-const headNonEmpty = unsafeHead;
-
-/** @internal */
-const SIZE = 5;
-/** @internal */
-const BUCKET_SIZE = /*#__PURE__*/Math.pow(2, SIZE);
-/** @internal */
-const MASK = BUCKET_SIZE - 1;
-/** @internal */
-const MAX_INDEX_NODE = BUCKET_SIZE / 2;
-/** @internal */
-const MIN_ARRAY_NODE = BUCKET_SIZE / 4;
-
-/**
- * Hamming weight.
- *
- * Taken from: http://jsperf.com/hamming-weight
- *
- * @internal
- */
-function popcount(x) {
-  x -= x >> 1 & 0x55555555;
-  x = (x & 0x33333333) + (x >> 2 & 0x33333333);
-  x = x + (x >> 4) & 0x0f0f0f0f;
-  x += x >> 8;
-  x += x >> 16;
-  return x & 0x7f;
-}
-/** @internal */
-function hashFragment(shift, h) {
-  return h >>> shift & MASK;
-}
-/** @internal */
-function toBitmap(x) {
-  return 1 << x;
-}
-/** @internal */
-function fromBitmap(bitmap, bit) {
-  return popcount(bitmap & bit - 1);
-}
-
-const make = (value, previous) => ({
-  value,
-  previous
-});
-
-/** @internal */
-function arrayUpdate(mutate, at, v, arr) {
-  let out = arr;
-  if (!mutate) {
-    const len = arr.length;
-    out = new Array(len);
-    for (let i = 0; i < len; ++i) out[i] = arr[i];
-  }
-  out[at] = v;
-  return out;
-}
-/** @internal */
-function arraySpliceOut(mutate, at, arr) {
-  const newLen = arr.length - 1;
-  let i = 0;
-  let g = 0;
-  let out = arr;
-  if (mutate) {
-    i = g = at;
-  } else {
-    out = new Array(newLen);
-    while (i < at) out[g++] = arr[i++];
-  }
-  ++i;
-  while (i <= newLen) out[g++] = arr[i++];
-  if (mutate) {
-    out.length = newLen;
-  }
-  return out;
-}
-/** @internal */
-function arraySpliceIn(mutate, at, v, arr) {
-  const len = arr.length;
-  if (mutate) {
-    let i = len;
-    while (i >= at) arr[i--] = arr[i];
-    arr[at] = v;
-    return arr;
-  }
-  let i = 0,
-    g = 0;
-  const out = new Array(len + 1);
-  while (i < at) out[g++] = arr[i++];
-  out[at] = v;
-  while (i < len) out[++g] = arr[i++];
-  return out;
-}
-
-/** @internal */
-class EmptyNode {
-  _tag = "EmptyNode";
-  modify(edit, _shift, f, hash, key, size) {
-    const v = f(none());
-    if (isNone(v)) return new EmptyNode();
-    ++size.value;
-    return new LeafNode(edit, hash, key, v);
-  }
-}
-/** @internal */
-function isEmptyNode(a) {
-  return isTagged(a, "EmptyNode");
-}
-/** @internal */
-function isLeafNode(node) {
-  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
-}
-/** @internal */
-function canEditNode(node, edit) {
-  return isEmptyNode(node) ? false : edit === node.edit;
-}
-/** @internal */
-class LeafNode {
-  edit;
-  hash;
-  key;
-  value;
-  _tag = "LeafNode";
-  constructor(edit, hash, key, value) {
-    this.edit = edit;
-    this.hash = hash;
-    this.key = key;
-    this.value = value;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    if (equals(key, this.key)) {
-      const v = f(this.value);
-      if (v === this.value) return this;else if (isNone(v)) {
-        --size.value;
-        return new EmptyNode();
-      }
-      if (canEditNode(this, edit)) {
-        this.value = v;
-        return this;
-      }
-      return new LeafNode(edit, hash, key, v);
-    }
-    const v = f(none());
-    if (isNone(v)) return this;
-    ++size.value;
-    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
-  }
-}
-/** @internal */
-class CollisionNode {
-  edit;
-  hash;
-  children;
-  _tag = "CollisionNode";
-  constructor(edit, hash, children) {
-    this.edit = edit;
-    this.hash = hash;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    if (hash === this.hash) {
-      const canEdit = canEditNode(this, edit);
-      const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size);
-      if (list === this.children) return this;
-      return list.length > 1 ? new CollisionNode(edit, this.hash, list) : list[0]; // collapse single element collision list
-    }
-    const v = f(none());
-    if (isNone(v)) return this;
-    ++size.value;
-    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
-  }
-  updateCollisionList(mutate, edit, hash, list, f, key, size) {
-    const len = list.length;
-    for (let i = 0; i < len; ++i) {
-      const child = list[i];
-      if ("key" in child && equals(key, child.key)) {
-        const value = child.value;
-        const newValue = f(value);
-        if (newValue === value) return list;
-        if (isNone(newValue)) {
-          --size.value;
-          return arraySpliceOut(mutate, i, list);
-        }
-        return arrayUpdate(mutate, i, new LeafNode(edit, hash, key, newValue), list);
-      }
-    }
-    const newValue = f(none());
-    if (isNone(newValue)) return list;
-    ++size.value;
-    return arrayUpdate(mutate, len, new LeafNode(edit, hash, key, newValue), list);
-  }
-}
-/** @internal */
-class IndexedNode {
-  edit;
-  mask;
-  children;
-  _tag = "IndexedNode";
-  constructor(edit, mask, children) {
-    this.edit = edit;
-    this.mask = mask;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    const mask = this.mask;
-    const children = this.children;
-    const frag = hashFragment(shift, hash);
-    const bit = toBitmap(frag);
-    const indx = fromBitmap(mask, bit);
-    const exists = mask & bit;
-    const canEdit = canEditNode(this, edit);
-    if (!exists) {
-      const _newChild = new EmptyNode().modify(edit, shift + SIZE, f, hash, key, size);
-      if (!_newChild) return this;
-      return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask, children) : new IndexedNode(edit, mask | bit, arraySpliceIn(canEdit, indx, _newChild, children));
-    }
-    const current = children[indx];
-    const child = current.modify(edit, shift + SIZE, f, hash, key, size);
-    if (current === child) return this;
-    let bitmap = mask;
-    let newChildren;
-    if (isEmptyNode(child)) {
-      // remove
-      bitmap &= ~bit;
-      if (!bitmap) return new EmptyNode();
-      if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
-        return children[indx ^ 1]; // collapse
-      }
-      newChildren = arraySpliceOut(canEdit, indx, children);
-    } else {
-      // modify
-      newChildren = arrayUpdate(canEdit, indx, child, children);
-    }
-    if (canEdit) {
-      this.mask = bitmap;
-      this.children = newChildren;
-      return this;
-    }
-    return new IndexedNode(edit, bitmap, newChildren);
-  }
-}
-/** @internal */
-class ArrayNode {
-  edit;
-  size;
-  children;
-  _tag = "ArrayNode";
-  constructor(edit, size, children) {
-    this.edit = edit;
-    this.size = size;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    let count = this.size;
-    const children = this.children;
-    const frag = hashFragment(shift, hash);
-    const child = children[frag];
-    const newChild = (child || new EmptyNode()).modify(edit, shift + SIZE, f, hash, key, size);
-    if (child === newChild) return this;
-    const canEdit = canEditNode(this, edit);
-    let newChildren;
-    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
-      // add
-      ++count;
-      newChildren = arrayUpdate(canEdit, frag, newChild, children);
-    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
-      // remove
-      --count;
-      if (count <= MIN_ARRAY_NODE) {
-        return pack(edit, count, frag, children);
-      }
-      newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
-    } else {
-      // modify
-      newChildren = arrayUpdate(canEdit, frag, newChild, children);
-    }
-    if (canEdit) {
-      this.size = count;
-      this.children = newChildren;
-      return this;
-    }
-    return new ArrayNode(edit, count, newChildren);
-  }
-}
-function pack(edit, count, removed, elements) {
-  const children = new Array(count - 1);
-  let g = 0;
-  let bitmap = 0;
-  for (let i = 0, len = elements.length; i < len; ++i) {
-    if (i !== removed) {
-      const elem = elements[i];
-      if (elem && !isEmptyNode(elem)) {
-        children[g++] = elem;
-        bitmap |= 1 << i;
-      }
-    }
-  }
-  return new IndexedNode(edit, bitmap, children);
-}
-function expand(edit, frag, child, bitmap, subNodes) {
-  const arr = [];
-  let bit = bitmap;
-  let count = 0;
-  for (let i = 0; bit; ++i) {
-    if (bit & 1) arr[i] = subNodes[count++];
-    bit >>>= 1;
-  }
-  arr[frag] = child;
-  return new ArrayNode(edit, count + 1, arr);
-}
-function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
-  if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
-  const subH1 = hashFragment(shift, h1);
-  const subH2 = hashFragment(shift, h2);
-  if (subH1 === subH2) {
-    return child => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
-  } else {
-    const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
-    return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
-  }
-}
-function mergeLeaves(edit, shift, h1, n1, h2, n2) {
-  let stack = undefined;
-  let currentShift = shift;
-  while (true) {
-    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
-    if (typeof res === "function") {
-      stack = make(res, stack);
-      currentShift = currentShift + SIZE;
-    } else {
-      let final = res;
-      while (stack != null) {
-        final = stack.value(final);
-        stack = stack.previous;
-      }
-      return final;
-    }
-  }
-}
-
-const HashMapSymbolKey = "effect/HashMap";
-/** @internal */
-const HashMapTypeId = /*#__PURE__*/Symbol.for(HashMapSymbolKey);
-const HashMapProto = {
-  [HashMapTypeId]: HashMapTypeId,
-  [Symbol.iterator]() {
-    return new HashMapIterator(this, (k, v) => [k, v]);
-  },
-  [symbol$1]() {
-    let hash$1 = hash(HashMapSymbolKey);
-    for (const item of this) {
-      hash$1 ^= pipe(hash(item[0]), combine(hash(item[1])));
-    }
-    return cached(this, hash$1);
-  },
-  [symbol](that) {
-    if (isHashMap(that)) {
-      if (that._size !== this._size) {
-        return false;
-      }
-      for (const item of this) {
-        const elem = pipe(that, getHash(item[0], hash(item[0])));
-        if (isNone(elem)) {
-          return false;
-        } else {
-          if (!equals(item[1], elem.value)) {
-            return false;
-          }
-        }
-      }
-      return true;
-    }
-    return false;
-  },
-  toString() {
-    return format(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "HashMap",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const makeImpl$1 = (editable, edit, root, size) => {
-  const map = Object.create(HashMapProto);
-  map._editable = editable;
-  map._edit = edit;
-  map._root = root;
-  map._size = size;
-  return map;
-};
-class HashMapIterator {
-  map;
-  f;
-  v;
-  constructor(map, f) {
-    this.map = map;
-    this.f = f;
-    this.v = visitLazy(this.map._root, this.f, undefined);
-  }
-  next() {
-    if (isNone(this.v)) {
-      return {
-        done: true,
-        value: undefined
-      };
-    }
-    const v0 = this.v.value;
-    this.v = applyCont(v0.cont);
-    return {
-      done: false,
-      value: v0.value
-    };
-  }
-  [Symbol.iterator]() {
-    return new HashMapIterator(this.map, this.f);
-  }
-}
-const applyCont = cont => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none();
-const visitLazy = (node, f, cont = undefined) => {
-  switch (node._tag) {
-    case "LeafNode":
-      {
-        if (isSome(node.value)) {
-          return some({
-            value: f(node.key, node.value.value),
-            cont
-          });
-        }
-        return applyCont(cont);
-      }
-    case "CollisionNode":
-    case "ArrayNode":
-    case "IndexedNode":
-      {
-        const children = node.children;
-        return visitLazyChildren(children.length, children, 0, f, cont);
-      }
-    default:
-      {
-        return applyCont(cont);
-      }
-  }
-};
-const visitLazyChildren = (len, children, i, f, cont) => {
-  while (i < len) {
-    const child = children[i++];
-    if (child && !isEmptyNode(child)) {
-      return visitLazy(child, f, [len, children, i, f, cont]);
-    }
-  }
-  return applyCont(cont);
-};
-const _empty$1 = /*#__PURE__*/makeImpl$1(false, 0, /*#__PURE__*/new EmptyNode(), 0);
-/** @internal */
-const empty$2 = () => _empty$1;
-/** @internal */
-const isHashMap = u => hasProperty(u, HashMapTypeId);
-/** @internal */
-const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
-  let node = self._root;
-  let shift = 0;
-  while (true) {
-    switch (node._tag) {
-      case "LeafNode":
-        {
-          return equals(key, node.key) ? node.value : none();
-        }
-      case "CollisionNode":
-        {
-          if (hash === node.hash) {
-            const children = node.children;
-            for (let i = 0, len = children.length; i < len; ++i) {
-              const child = children[i];
-              if ("key" in child && equals(key, child.key)) {
-                return child.value;
-              }
-            }
-          }
-          return none();
-        }
-      case "IndexedNode":
-        {
-          const frag = hashFragment(shift, hash);
-          const bit = toBitmap(frag);
-          if (node.mask & bit) {
-            node = node.children[fromBitmap(node.mask, bit)];
-            shift += SIZE;
-            break;
-          }
-          return none();
-        }
-      case "ArrayNode":
-        {
-          node = node.children[hashFragment(shift, hash)];
-          if (node) {
-            shift += SIZE;
-            break;
-          }
-          return none();
-        }
-      default:
-        return none();
-    }
-  }
-});
-/** @internal */
-const set = /*#__PURE__*/dual(3, (self, key, value) => modifyAt(self, key, () => some(value)));
-/** @internal */
-const setTree = /*#__PURE__*/dual(3, (self, newRoot, newSize) => {
-  if (self._editable) {
-    self._root = newRoot;
-    self._size = newSize;
-    return self;
-  }
-  return newRoot === self._root ? self : makeImpl$1(self._editable, self._edit, newRoot, newSize);
-});
-/** @internal */
-const keys = self => new HashMapIterator(self, key => key);
-/** @internal */
-const size$2 = self => self._size;
-/** @internal */
-const beginMutation$1 = self => makeImpl$1(true, self._edit + 1, self._root, self._size);
-/** @internal */
-const modifyAt = /*#__PURE__*/dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
-/** @internal */
-const modifyHash = /*#__PURE__*/dual(4, (self, key, hash, f) => {
-  const size = {
-    value: self._size
-  };
-  const newRoot = self._root.modify(self._editable ? self._edit : NaN, 0, f, hash, key, size);
-  return pipe(self, setTree(newRoot, size.value));
-});
-/** @internal */
-const forEach$1 = /*#__PURE__*/dual(2, (self, f) => reduce$1(self, void 0, (_, value, key) => f(value, key)));
-/** @internal */
-const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
-  const root = self._root;
-  if (root._tag === "LeafNode") {
-    return isSome(root.value) ? f(zero, root.value.value, root.key) : zero;
-  }
-  if (root._tag === "EmptyNode") {
-    return zero;
-  }
-  const toVisit = [root.children];
-  let children;
-  while (children = toVisit.pop()) {
-    for (let i = 0, len = children.length; i < len;) {
-      const child = children[i++];
-      if (child && !isEmptyNode(child)) {
-        if (child._tag === "LeafNode") {
-          if (isSome(child.value)) {
-            zero = f(zero, child.value.value, child.key);
-          }
-        } else {
-          toVisit.push(child.children);
-        }
-      }
-    }
-  }
-  return zero;
-});
-
-const HashSetSymbolKey = "effect/HashSet";
-/** @internal */
-const HashSetTypeId = /*#__PURE__*/Symbol.for(HashSetSymbolKey);
-const HashSetProto = {
-  [HashSetTypeId]: HashSetTypeId,
-  [Symbol.iterator]() {
-    return keys(this._keyMap);
-  },
-  [symbol$1]() {
-    return cached(this, combine(hash(this._keyMap))(hash(HashSetSymbolKey)));
-  },
-  [symbol](that) {
-    if (isHashSet(that)) {
-      return size$2(this._keyMap) === size$2(that._keyMap) && equals(this._keyMap, that._keyMap);
-    }
-    return false;
-  },
-  toString() {
-    return format(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "HashSet",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const makeImpl = keyMap => {
-  const set = Object.create(HashSetProto);
-  set._keyMap = keyMap;
-  return set;
-};
-/** @internal */
-const isHashSet = u => hasProperty(u, HashSetTypeId);
-const _empty = /*#__PURE__*/makeImpl(/*#__PURE__*/empty$2());
-/** @internal */
-const empty$1 = () => _empty;
-/** @internal */
-const size$1 = self => size$2(self._keyMap);
-/** @internal */
-const beginMutation = self => makeImpl(beginMutation$1(self._keyMap));
-/** @internal */
-const endMutation = self => {
-  self._keyMap._editable = false;
-  return self;
-};
-/** @internal */
-const mutate = /*#__PURE__*/dual(2, (self, f) => {
-  const transient = beginMutation(self);
-  f(transient);
-  return endMutation(transient);
-});
-/** @internal */
-const add$1 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (set(value, true)(self._keyMap), self) : makeImpl(set(value, true)(self._keyMap)));
-/** @internal */
-const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$1(), set => {
-  forEach(self, value => add$1(set, value));
-  for (const value of that) {
-    add$1(set, value);
-  }
-}));
-/** @internal */
-const forEach = /*#__PURE__*/dual(2, (self, f) => forEach$1(self._keyMap, (_, k) => f(k)));
-
-/**
- * # HashSet
- *
- * An immutable `HashSet` provides a collection of unique values with efficient
- * lookup, insertion and removal. Once created, a `HashSet` cannot be modified;
- * any operation that would alter the set instead returns a new `HashSet` with
- * the changes. This immutability offers benefits like predictable state
- * management and easier reasoning about your code.
- *
- * ## What Problem Does It Solve?
- *
- * `HashSet` solves the problem of maintaining an unsorted collection where each
- * value appears exactly once, with fast operations for checking membership and
- * adding/removing values.
- *
- * ## When to Use
- *
- * Use `HashSet` when you need:
- *
- * - A collection with no duplicate values
- * - Efficient membership testing (**`O(1)`** average complexity)
- * - Set operations like union, intersection, and difference
- * - An immutable data structure that preserves functional programming patterns
- *
- * ## Advanced Features
- *
- * HashSet provides operations for:
- *
- * - Transforming sets with map and flatMap
- * - Filtering elements with filter
- * - Combining sets with union, intersection and difference
- * - Performance optimizations via mutable operations in controlled contexts
- *
- * ## Performance Characteristics
- *
- * - **Lookup** operations ({@link module:HashSet.has}): **`O(1)`** average time
- *   complexity
- * - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time
- *   complexity
- * - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average
- *   time complexity
- * - **Set** operations ({@link module:HashSet.union},
- *   {@link module:HashSet.intersection}): **`O(n)`** where n is the size of the
- *   smaller set
- * - **Iteration**: **`O(n)`** where n is the size of the set
- *
- * The HashSet data structure implements the following traits:
- *
- * - {@link Iterable}: allows iterating over the values in the set
- * - {@link Equal}: allows comparing two sets for value-based equality
- * - {@link Pipeable}: allows chaining operations with the pipe operator
- * - {@link Inspectable}: allows inspecting the contents of the set
- *
- * ## Operations Reference
- *
- * | Category     | Operation                           | Description                                 | Complexity |
- * | ------------ | ----------------------------------- | ------------------------------------------- | ---------- |
- * | constructors | {@link module:HashSet.empty}        | Creates an empty HashSet                    | O(1)       |
- * | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable          | O(n)       |
- * | constructors | {@link module:HashSet.make}         | Creates a HashSet from multiple values      | O(n)       |
- * |              |                                     |                                             |            |
- * | elements     | {@link module:HashSet.has}          | Checks if a value exists in the set         | O(1) avg   |
- * | elements     | {@link module:HashSet.some}         | Checks if any element satisfies a predicate | O(n)       |
- * | elements     | {@link module:HashSet.every}        | Checks if all elements satisfy a predicate  | O(n)       |
- * | elements     | {@link module:HashSet.isSubset}     | Checks if a set is a subset of another      | O(n)       |
- * |              |                                     |                                             |            |
- * | getters      | {@link module:HashSet.values}       | Gets an iterator of all values              | O(1)       |
- * | getters      | {@link module:HashSet.toValues}     | Gets an array of all values                 | O(n)       |
- * | getters      | {@link module:HashSet.size}         | Gets the number of elements                 | O(1)       |
- * |              |                                     |                                             |            |
- * | mutations    | {@link module:HashSet.add}          | Adds a value to the set                     | O(1) avg   |
- * | mutations    | {@link module:HashSet.remove}       | Removes a value from the set                | O(1) avg   |
- * | mutations    | {@link module:HashSet.toggle}       | Toggles a value's presence                  | O(1) avg   |
- * |              |                                     |                                             |            |
- * | operations   | {@link module:HashSet.difference}   | Computes set difference (A - B)             | O(n)       |
- * | operations   | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B)           | O(n)       |
- * | operations   | {@link module:HashSet.union}        | Computes set union (A ∪ B)                  | O(n)       |
- * |              |                                     |                                             |            |
- * | mapping      | {@link module:HashSet.map}          | Transforms each element                     | O(n)       |
- * |              |                                     |                                             |            |
- * | sequencing   | {@link module:HashSet.flatMap}      | Transforms and flattens elements            | O(n)       |
- * |              |                                     |                                             |            |
- * | traversing   | {@link module:HashSet.forEach}      | Applies a function to each element          | O(n)       |
- * |              |                                     |                                             |            |
- * | folding      | {@link module:HashSet.reduce}       | Reduces the set to a single value           | O(n)       |
- * |              |                                     |                                             |            |
- * | filtering    | {@link module:HashSet.filter}       | Keeps elements that satisfy a predicate     | O(n)       |
- * |              |                                     |                                             |            |
- * | partitioning | {@link module:HashSet.partition}    | Splits into two sets by a predicate         | O(n)       |
- *
- * ## Notes
- *
- * ### Composability with the Effect Ecosystem:
- *
- * This `HashSet` is designed to work seamlessly within the Effect ecosystem. It
- * implements the {@link Iterable}, {@link Equal}, {@link Pipeable}, and
- * {@link Inspectable} traits from Effect. This ensures compatibility with other
- * Effect data structures and functionalities. For example, you can easily use
- * Effect's `pipe` method to chain operations on the `HashSet`.
- *
- * **Equality of Elements with Effect's {@link Equal `Equal`} Trait:**
- *
- * This `HashSet` relies on Effect's {@link Equal} trait to determine the
- * uniqueness of elements within the set. The way equality is checked depends on
- * the type of the elements:
- *
- * - **Primitive Values:** For primitive JavaScript values like strings, numbers,
- *   booleans, `null`, and `undefined`, equality is determined by their value
- *   (similar to the `===` operator).
- * - **Objects and Custom Types:** For objects and other custom types, equality is
- *   determined by whether those types implement the {@link Equal} interface
- *   themselves. If an element type implements `Equal`, the `HashSet` will
- *   delegate to that implementation to perform the equality check. This allows
- *   you to define custom logic for determining when two instances of your
- *   objects should be considered equal based on their properties, rather than
- *   just their object identity.
- *
- * ```ts
- * import { Equal, Hash, HashSet } from "effect"
- *
- * class Person implements Equal.Equal {
- *   constructor(
- *     readonly id: number, // Unique identifier
- *     readonly name: string,
- *     readonly age: number
- *   ) {}
- *
- *   // Define equality based on id, name, and age
- *   [Equal.symbol](that: Equal.Equal): boolean {
- *     if (that instanceof Person) {
- *       return (
- *         Equal.equals(this.id, that.id) &&
- *         Equal.equals(this.name, that.name) &&
- *         Equal.equals(this.age, that.age)
- *       )
- *     }
- *     return false
- *   }
- *
- *   // Generate a hash code based on the unique id
- *   [Hash.symbol](): number {
- *     return Hash.hash(this.id)
- *   }
- * }
- *
- * // Creating a HashSet with objects that implement the Equal interface
- * const set = HashSet.empty().pipe(
- *   HashSet.add(new Person(1, "Alice", 30)),
- *   HashSet.add(new Person(1, "Alice", 30))
- * )
- *
- * // HashSet recognizes them as equal, so only one element is stored
- * console.log(HashSet.size(set))
- * // Output: 1
- * ```
- *
- * **Simplifying Equality and Hashing with `Data` and `Schema`:**
- *
- * Effect's {@link Data} and {@link Schema `Schema.Data`} modules offer powerful
- * ways to automatically handle the implementation of both the {@link Equal} and
- * {@link Hash} traits for your custom data structures.
- *
- * - **`Data` Module:** By using constructors like `Data.struct`, `Data.tuple`,
- *   `Data.array`, or `Data.case` to define your data types, Effect
- *   automatically generates the necessary implementations for value-based
- *   equality and consistent hashing. This significantly reduces boilerplate and
- *   ensures correctness.
- *
- * ```ts
- * import { HashSet, Data, Equal } from "effect"
- * import assert from "node:assert/strict"
- *
- * // Data.* implements the `Equal` traits for us
- * const person1 = Data.struct({ id: 1, name: "Alice", age: 30 })
- * const person2 = Data.struct({ id: 1, name: "Alice", age: 30 })
- *
- * assert(Equal.equals(person1, person2))
- *
- * const set = HashSet.empty().pipe(
- *   HashSet.add(person1),
- *   HashSet.add(person2)
- * )
- *
- * // HashSet recognizes them as equal, so only one element is stored
- * console.log(HashSet.size(set)) // Output: 1
- * ```
- *
- * - **`Schema` Module:** When defining data schemas using the {@link Schema}
- *   module, you can use `Schema.Data` to automatically include the `Equal` and
- *   `Hash` traits in the decoded objects. This is particularly important when
- *   working with `HashSet`. **For decoded objects to be correctly recognized as
- *   equal within a `HashSet`, ensure that the schema for those objects is
- *   defined using `Schema.Data`.**
- *
- * ```ts
- * import { Equal, HashSet, Schema } from "effect"
- * import assert from "node:assert/strict"
- *
- * // Schema.Data implements the `Equal` traits for us
- * const PersonSchema = Schema.Data(
- *   Schema.Struct({
- *     id: Schema.Number,
- *     name: Schema.String,
- *     age: Schema.Number
- *   })
- * )
- *
- * const Person = Schema.decode(PersonSchema)
- *
- * const person1 = Person({ id: 1, name: "Alice", age: 30 })
- * const person2 = Person({ id: 1, name: "Alice", age: 30 })
- *
- * assert(Equal.equals(person1, person2)) // Output: true
- *
- * const set = HashSet.empty().pipe(
- *   HashSet.add(person1),
- *   HashSet.add(person2)
- * )
- *
- * // HashSet thanks to Schema.Data implementation of the `Equal` trait, recognizes the two Person as equal, so only one element is stored
- * console.log(HashSet.size(set)) // Output: 1
- * ```
- *
- * ### Interoperability with the JavaScript Runtime:
- *
- * To interoperate with the regular JavaScript runtime, Effect's `HashSet`
- * provides methods to access its elements in formats readily usable by
- * JavaScript APIs: {@link values `HashSet.values`},
- * {@link toValues `HashSet.toValues`}
- *
- * ```ts
- * import { HashSet } from "effect"
- *
- * const hashSet: HashSet.HashSet<number> = HashSet.make(1, 2, 3)
- *
- * // Using HashSet.values to convert HashSet.HashSet<A> to IterableIterator<A>
- * const iterable: IterableIterator<number> = HashSet.values(hashSet)
- *
- * console.log(...iterable) // Logs:  1 2 3
- *
- * // Using HashSet.toValues to convert HashSet.HashSet<A> to Array<A>
- * const array: Array<number> = HashSet.toValues(hashSet)
- *
- * console.log(array) // Logs: [ 1, 2, 3 ]
- * ```
- *
- * Be mindful of performance implications (both time and space complexity) when
- * frequently converting between Effect's immutable HashSet and mutable
- * JavaScript data structures, especially for large collections.
- *
- * @module HashSet
- * @since 2.0.0
- */
-/**
- * Creates an empty `HashSet`.
- *
- * Time complexity: **`O(1)`**
- *
- * @memberof HashSet
- * @since 2.0.0
- * @category constructors
- * @example
- *
- * ```ts
- * import { HashSet, pipe } from "effect"
- *
- * console.log(
- *   pipe(
- *     // Provide a type argument to create a HashSet of a specific type
- *     HashSet.empty<number>(),
- *     HashSet.add(1),
- *     HashSet.add(1), // Notice the duplicate
- *     HashSet.add(2),
- *     HashSet.toValues
- *   )
- * ) // Output: [1, 2]
- * ```
- *
- * @see Other `HashSet` constructors are {@link module:HashSet.make} {@link module:HashSet.fromIterable}
- */
-const empty = empty$1;
-/**
- * Calculates the number of values in the `HashSet`.
- *
- * Time complexity: **`O(1)`**
- *
- * @memberof HashSet
- * @since 2.0.0
- * @category getters
- * @example
- *
- * ```ts
- * import { HashSet, pipe } from "effect"
- * import assert from "node:assert/strict"
- *
- * assert.deepStrictEqual(pipe(HashSet.empty(), HashSet.size), 0)
- *
- * assert.deepStrictEqual(
- *   pipe(HashSet.make(1, 2, 2, 3, 4, 3), HashSet.size),
- *   4
- * )
- * ```
- *
- * @see Other `HashSet` getters are {@link module:HashSet.values} {@link module:HashSet.toValues}
- */
-const size = size$1;
-/**
- * Adds a value to the `HashSet`.
- *
- * Time complexity: **`O(1)`** average
- *
- * @remarks
- * Remember that a `HashSet` is a collection of unique values, so adding a value
- * that already exists in the `HashSet` will not add a duplicate.
- *
- * Remember that HashSet is an immutable data structure, so the `add` function,
- * like all other functions that modify the HashSet, will return a new HashSet
- * with the added value.
- * @memberof HashSet
- * @since 2.0.0
- * @example
- *
- * ```ts
- * // Syntax
- * import { HashSet, pipe } from "effect"
- *
- * // with data-last, a.k.a. pipeable API
- * pipe(HashSet.empty(), HashSet.add(0), HashSet.add(0))
- *
- * // or piped with the pipe function
- * HashSet.empty().pipe(HashSet.add(0))
- *
- * // or with data-first API
- * HashSet.add(HashSet.empty(), 0)
- * ```
- *
- * @see Other `HashSet` mutations are {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
- */
-const add = add$1;
-/**
- * Computes the set union `( self ∪ that )` between this `HashSet` and the
- * specified `Iterable<A>`.
- *
- * Time complexity: **`O(n)`** where n is the number of elements in the set
- *
- * **NOTE**: the hash and equal of the values in both the set and the iterable
- * must be the same.
- *
- * @memberof HashSet
- * @since 2.0.0
- * @example
- *
- * ```ts
- * // Syntax
- * import { HashSet, pipe } from "effect"
- *
- * // with data-last, a.k.a. pipeable API
- * pipe(HashSet.make(1, 2, 3), HashSet.union(HashSet.make(3, 4, 5)))
- *
- * // or piped with the pipe function
- * HashSet.make(1, 2, 3).pipe(HashSet.union(HashSet.make(3, 4, 5)))
- *
- * // or with data-first API
- * HashSet.union(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5))
- * ```
- *
- * @see Other `HashSet` operations are {@link module:HashSet.difference} {@link module:HashSet.intersection}
- */
-const union = union$1;
-
-/** @internal */
-const OP_DIE = "Die";
-/** @internal */
-const OP_EMPTY = "Empty";
-/** @internal */
-const OP_FAIL = "Fail";
-/** @internal */
-const OP_INTERRUPT = "Interrupt";
-/** @internal */
-const OP_PARALLEL = "Parallel";
-/** @internal */
-const OP_SEQUENTIAL = "Sequential";
-
-// -----------------------------------------------------------------------------
-// Models
-// -----------------------------------------------------------------------------
-/** @internal */
-const CauseSymbolKey = "effect/Cause";
-/** @internal */
-const CauseTypeId = /*#__PURE__*/Symbol.for(CauseSymbolKey);
-const variance = {
-  /* c8 ignore next */
-  _E: _ => _
-};
-/** @internal */
-const proto = {
-  [CauseTypeId]: variance,
-  [symbol$1]() {
-    return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))), cached(this));
-  },
-  [symbol](that) {
-    return isCause(that) && causeEquals(this, that);
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  },
-  toJSON() {
-    switch (this._tag) {
-      case "Empty":
-        return {
-          _id: "Cause",
-          _tag: this._tag
-        };
-      case "Die":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          defect: toJSON(this.defect)
-        };
-      case "Interrupt":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          fiberId: this.fiberId.toJSON()
-        };
-      case "Fail":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          failure: toJSON(this.error)
-        };
-      case "Sequential":
-      case "Parallel":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          left: toJSON(this.left),
-          right: toJSON(this.right)
-        };
-    }
-  },
-  toString() {
-    return pretty(this);
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-};
-/** @internal */
-const fail$1 = error => {
-  const o = Object.create(proto);
-  o._tag = OP_FAIL;
-  o.error = error;
-  return o;
-};
-/** @internal */
-const parallel = (left, right) => {
-  const o = Object.create(proto);
-  o._tag = OP_PARALLEL;
-  o.left = left;
-  o.right = right;
-  return o;
-};
-/** @internal */
-const sequential = (left, right) => {
-  const o = Object.create(proto);
-  o._tag = OP_SEQUENTIAL;
-  o.left = left;
-  o.right = right;
-  return o;
-};
-// -----------------------------------------------------------------------------
-// Refinements
-// -----------------------------------------------------------------------------
-/** @internal */
-const isCause = u => hasProperty(u, CauseTypeId);
-/** @internal */
-const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
-/** @internal */
-const causeEquals = (left, right) => {
-  let leftStack = of(left);
-  let rightStack = of(right);
-  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
-    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce([empty(), empty$3()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
-    }));
-    const [rightParallel, rightSequential] = pipe(headNonEmpty(rightStack), reduce([empty(), empty$3()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
-    }));
-    if (!equals(leftParallel, rightParallel)) {
-      return false;
-    }
-    leftStack = leftSequential;
-    rightStack = rightSequential;
-  }
-  return true;
-};
-// -----------------------------------------------------------------------------
-// Flattening
-// -----------------------------------------------------------------------------
-/**
- * Flattens a cause to a sequence of sets of causes, where each set represents
- * causes that fail in parallel and sequential sets represent causes that fail
- * after each other.
- *
- * @internal
- */
-const flattenCause = cause => {
-  return flattenCauseLoop(of(cause), empty$3());
-};
-/** @internal */
-const flattenCauseLoop = (causes, flattened) => {
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = pipe(causes, reduce$2([empty(), empty$3()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return [pipe(parallel, union(par)), pipe(sequential, appendAll(seq))];
-    }));
-    const updated = size(parallel) > 0 ? pipe(flattened, prepend(parallel)) : flattened;
-    if (isEmpty(sequential)) {
-      return reverse(updated);
-    }
-    causes = sequential;
-    flattened = updated;
-  }
-  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
-};
-// -----------------------------------------------------------------------------
-// Evaluation
-// -----------------------------------------------------------------------------
-/**
- * Takes one step in evaluating a cause, returning a set of causes that fail
- * in parallel and a list of causes that fail sequentially after those causes.
- *
- * @internal
- */
-const evaluateCause = self => {
-  let cause = self;
-  const stack = [];
-  let _parallel = empty();
-  let _sequential = empty$3();
-  while (cause !== undefined) {
-    switch (cause._tag) {
-      case OP_EMPTY:
-        {
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
-          break;
-        }
-      case OP_FAIL:
-        {
-          _parallel = add(_parallel, make$1(cause._tag, cause.error));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
-          break;
-        }
-      case OP_DIE:
-        {
-          _parallel = add(_parallel, make$1(cause._tag, cause.defect));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
-          break;
-        }
-      case OP_INTERRUPT:
-        {
-          _parallel = add(_parallel, make$1(cause._tag, cause.fiberId));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
-          break;
-        }
-      case OP_SEQUENTIAL:
-        {
-          switch (cause.left._tag) {
-            case OP_EMPTY:
-              {
-                cause = cause.right;
-                break;
-              }
-            case OP_SEQUENTIAL:
-              {
-                cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
-                break;
-              }
-            case OP_PARALLEL:
-              {
-                cause = parallel(sequential(cause.left.left, cause.right), sequential(cause.left.right, cause.right));
-                break;
-              }
-            default:
-              {
-                _sequential = prepend(_sequential, cause.right);
-                cause = cause.left;
-                break;
-              }
-          }
-          break;
-        }
-      case OP_PARALLEL:
-        {
-          stack.push(cause.right);
-          cause = cause.left;
-          break;
-        }
-    }
-  }
-  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
-};
-/** @internal */
-const IsInterruptedOnlyCauseReducer = {
-  emptyCase: constTrue,
-  failCase: constFalse,
-  dieCase: constFalse,
-  interruptCase: constTrue,
-  sequentialCase: (_, left, right) => left && right,
-  parallelCase: (_, left, right) => left && right
-};
-const OP_SEQUENTIAL_CASE = "SequentialCase";
-const OP_PARALLEL_CASE = "ParallelCase";
-/** @internal */
-const reduce = /*#__PURE__*/dual(3, (self, zero, pf) => {
-  let accumulator = zero;
-  let cause = self;
-  const causes = [];
-  while (cause !== undefined) {
-    const option = pf(accumulator, cause);
-    accumulator = isSome(option) ? option.value : accumulator;
-    switch (cause._tag) {
-      case OP_SEQUENTIAL:
-        {
-          causes.push(cause.right);
-          cause = cause.left;
-          break;
-        }
-      case OP_PARALLEL:
-        {
-          causes.push(cause.right);
-          cause = cause.left;
-          break;
-        }
-      default:
-        {
-          cause = undefined;
-          break;
-        }
-    }
-    if (cause === undefined && causes.length > 0) {
-      cause = causes.pop();
-    }
-  }
-  return accumulator;
-});
-/** @internal */
-const reduceWithContext = /*#__PURE__*/dual(3, (self, context, reducer) => {
-  const input = [self];
-  const output = [];
-  while (input.length > 0) {
-    const cause = input.pop();
-    switch (cause._tag) {
-      case OP_EMPTY:
-        {
-          output.push(right(reducer.emptyCase(context)));
-          break;
-        }
-      case OP_FAIL:
-        {
-          output.push(right(reducer.failCase(context, cause.error)));
-          break;
-        }
-      case OP_DIE:
-        {
-          output.push(right(reducer.dieCase(context, cause.defect)));
-          break;
-        }
-      case OP_INTERRUPT:
-        {
-          output.push(right(reducer.interruptCase(context, cause.fiberId)));
-          break;
-        }
-      case OP_SEQUENTIAL:
-        {
-          input.push(cause.right);
-          input.push(cause.left);
-          output.push(left({
-            _tag: OP_SEQUENTIAL_CASE
-          }));
-          break;
-        }
-      case OP_PARALLEL:
-        {
-          input.push(cause.right);
-          input.push(cause.left);
-          output.push(left({
-            _tag: OP_PARALLEL_CASE
-          }));
-          break;
-        }
-    }
-  }
-  const accumulator = [];
-  while (output.length > 0) {
-    const either = output.pop();
-    switch (either._tag) {
-      case "Left":
-        {
-          switch (either.left._tag) {
-            case OP_SEQUENTIAL_CASE:
-              {
-                const left = accumulator.pop();
-                const right = accumulator.pop();
-                const value = reducer.sequentialCase(context, left, right);
-                accumulator.push(value);
-                break;
-              }
-            case OP_PARALLEL_CASE:
-              {
-                const left = accumulator.pop();
-                const right = accumulator.pop();
-                const value = reducer.parallelCase(context, left, right);
-                accumulator.push(value);
-                break;
-              }
-          }
-          break;
-        }
-      case "Right":
-        {
-          accumulator.push(either.right);
-          break;
-        }
-    }
-  }
-  if (accumulator.length === 0) {
-    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues");
-  }
-  return accumulator.pop();
-});
-// -----------------------------------------------------------------------------
-// Pretty Printing
-// -----------------------------------------------------------------------------
-/** @internal */
-const pretty = (cause, options) => {
-  if (isInterruptedOnly(cause)) {
-    return "All fibers interrupted without errors.";
-  }
-  return prettyErrors(cause).map(function (e) {
-    if (options?.renderErrorCause !== true || e.cause === undefined) {
-      return e.stack;
-    }
-    return `${e.stack} {\n${renderErrorCause(e.cause, "  ")}\n}`;
-  }).join("\n");
-};
-const renderErrorCause = (cause, prefix) => {
-  const lines = cause.stack.split("\n");
-  let stack = `${prefix}[cause]: ${lines[0]}`;
-  for (let i = 1, len = lines.length; i < len; i++) {
-    stack += `\n${prefix}${lines[i]}`;
-  }
-  if (cause.cause) {
-    stack += ` {\n${renderErrorCause(cause.cause, `${prefix}  `)}\n${prefix}}`;
-  }
-  return stack;
-};
-/** @internal */
-const makePrettyError = originalError => {
-  const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
-  const prevLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 1;
-  const error = new Error(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
-    cause: makePrettyError(originalError.cause)
-  } : undefined);
-  Error.stackTraceLimit = prevLimit;
-  if (error.message === "") {
-    error.message = "An error has occurred";
-  }
-  Error.stackTraceLimit = prevLimit;
-  error.name = originalError instanceof Error ? originalError.name : "Error";
-  if (originalErrorIsObject) {
-    if (spanSymbol in originalError) {
-      error.span = originalError[spanSymbol];
-    }
-    Object.keys(originalError).forEach(key => {
-      if (!(key in error)) {
-        // @ts-expect-error
-        error[key] = originalError[key];
-      }
-    });
-  }
-  error.stack = prettyErrorStack(`${error.name}: ${error.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", error.span);
-  return error;
-};
-/**
- * A utility function for generating human-readable error messages from a generic error of type `unknown`.
- *
- * Rules:
- *
- * 1) If the input `u` is already a string, it's considered a message.
- * 2) If `u` is an Error instance with a message defined, it uses the message.
- * 3) If `u` has a user-defined `toString()` method, it uses that method.
- * 4) Otherwise, it uses `Inspectable.stringifyCircular` to produce a string representation and uses it as the error message,
- *   with "Error" added as a prefix.
- *
- * @internal
- */
-const prettyErrorMessage = u => {
-  // 1)
-  if (typeof u === "string") {
-    return u;
-  }
-  // 2)
-  if (typeof u === "object" && u !== null && u instanceof Error) {
-    return u.message;
-  }
-  // 3)
-  try {
-    if (hasProperty(u, "toString") && isFunction(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
-      return u["toString"]();
-    }
-  } catch {
-    // something's off, rollback to json
-  }
-  // 4)
-  return stringifyCircular(u);
-};
-const locationRegex = /\((.*)\)/g;
-/** @internal */
-const spanToTrace = /*#__PURE__*/globalValue("effect/Tracer/spanToTrace", () => new WeakMap());
-const prettyErrorStack = (message, stack, span) => {
-  const out = [message];
-  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
-      i++;
-      continue;
-    }
-    if (lines[i].includes("Generator.next")) {
-      break;
-    }
-    if (lines[i].includes("effect_internal_function")) {
-      break;
-    }
-    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
-  }
-  if (span) {
-    let current = span;
-    let i = 0;
-    while (current && current._tag === "Span" && i < 10) {
-      const stackFn = spanToTrace.get(current);
-      if (typeof stackFn === "function") {
-        const stack = stackFn();
-        if (typeof stack === "string") {
-          const locationMatchAll = stack.matchAll(locationRegex);
-          let match = false;
-          for (const [, location] of locationMatchAll) {
-            match = true;
-            out.push(`    at ${current.name} (${location})`);
-          }
-          if (!match) {
-            out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`);
-          }
-        } else {
-          out.push(`    at ${current.name}`);
-        }
-      } else {
-        out.push(`    at ${current.name}`);
-      }
-      current = getOrUndefined(current.parent);
-      i++;
-    }
-  }
-  return out.join("\n");
-};
-/** @internal */
-const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
-/** @internal */
-const prettyErrors = cause => reduceWithContext(cause, void 0, {
-  emptyCase: () => [],
-  dieCase: (_, unknownError) => {
-    return [makePrettyError(unknownError)];
-  },
-  failCase: (_, error) => {
-    return [makePrettyError(error)];
-  },
-  interruptCase: () => [],
-  parallelCase: (_, l, r) => [...l, ...r],
-  sequentialCase: (_, l, r) => [...l, ...r]
-});
-
-/** @internal */
-class SingleShotGen {
-  self;
-  called = false;
-  constructor(self) {
-    this.self = self;
-  }
-  next(a) {
-    return this.called ? {
-      value: a,
-      done: true
-    } : (this.called = true, {
-      value: this.self,
-      done: false
-    });
-  }
-  return(a) {
-    return {
-      value: a,
-      done: true
-    };
-  }
-  throw(e) {
-    throw e;
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(this.self);
-  }
-}
-
-/** @internal */
-const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
-class EffectPrimitive {
-  _op;
-  effect_instruction_i0 = undefined;
-  effect_instruction_i1 = undefined;
-  effect_instruction_i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = effectVariance;
-  constructor(_op) {
-    this._op = _op;
-  }
-  [symbol](that) {
-    return this === that;
-  }
-  [symbol$1]() {
-    return cached(this, random(this));
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Effect",
-      _op: this._op,
-      effect_instruction_i0: toJSON(this.effect_instruction_i0),
-      effect_instruction_i1: toJSON(this.effect_instruction_i1),
-      effect_instruction_i2: toJSON(this.effect_instruction_i2)
-    };
-  }
-  toString() {
-    return format(this.toJSON());
-  }
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-}
-/** @internal */
-class EffectPrimitiveFailure {
-  _op;
-  effect_instruction_i0 = undefined;
-  effect_instruction_i1 = undefined;
-  effect_instruction_i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = effectVariance;
-  constructor(_op) {
-    this._op = _op;
-    // @ts-expect-error
-    this._tag = _op;
-  }
-  [symbol](that) {
-    return exitIsExit(that) && that._op === "Failure" &&
-    // @ts-expect-error
-    equals(this.effect_instruction_i0, that.effect_instruction_i0);
-  }
-  [symbol$1]() {
-    return pipe(
-    // @ts-expect-error
-    string(this._tag),
-    // @ts-expect-error
-    combine(hash(this.effect_instruction_i0)), cached(this));
-  }
-  get cause() {
-    return this.effect_instruction_i0;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Exit",
-      _tag: this._op,
-      cause: this.cause.toJSON()
-    };
-  }
-  toString() {
-    return format(this.toJSON());
-  }
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-}
-/** @internal */
-const isEffect = u => hasProperty(u, EffectTypeId);
-/* @internal */
-const withFiberRuntime = withRuntime => {
-  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
-  effect.effect_instruction_i0 = withRuntime;
-  return effect;
-};
-const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
-/* @internal */
-const capture = (obj, span) => {
-  if (isSome(span)) {
-    return new Proxy(obj, {
-      has(target, p) {
-        return p === spanSymbol || p === originalSymbol || p in target;
-      },
-      get(target, p) {
-        if (p === spanSymbol) {
-          return span.value;
-        }
-        if (p === originalSymbol) {
-          return obj;
-        }
-        // @ts-expect-error
-        return target[p];
-      }
-    });
-  }
-  return obj;
-};
-/* @internal */
-const fail = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause(fail$1(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail$1(error));
-/* @internal */
-const failCause = cause => {
-  const effect = new EffectPrimitiveFailure(OP_FAILURE);
-  effect.effect_instruction_i0 = cause;
-  return effect;
-};
-// -----------------------------------------------------------------------------
-// Errors
-// -----------------------------------------------------------------------------
-/** @internal */
-const YieldableError = /*#__PURE__*/function () {
-  class YieldableError extends globalThis.Error {
-    commit() {
-      return fail(this);
-    }
-    toJSON() {
-      const obj = {
-        ...this
-      };
-      if (this.message) obj.message = this.message;
-      if (this.cause) obj.cause = this.cause;
-      return obj;
-    }
-    [NodeInspectSymbol]() {
-      if (this.toString !== globalThis.Error.prototype.toString) {
-        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
-      } else if ("Bun" in globalThis) {
-        return pretty(fail$1(this), {
-          renderErrorCause: true
-        });
-      }
-      return this;
-    }
-  }
-  // @effect-diagnostics-next-line floatingEffect:off
-  Object.assign(YieldableError.prototype, StructuralCommitPrototype);
-  return YieldableError;
-}();
-// -----------------------------------------------------------------------------
-// Exit
-// -----------------------------------------------------------------------------
-/** @internal */
-const exitIsExit = u => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
-// -----------------------------------------------------------------------------
-// Tracing
-// -----------------------------------------------------------------------------
-/** @internal */
-const currentSpanFromFiber = fiber => {
-  const span = fiber.currentSpan;
-  return span !== undefined && span._tag === "Span" ? some(span) : none();
-};
-
-const hasProcessStdout = typeof process === "object" && process !== null && typeof process.stdout === "object" && process.stdout !== null;
-hasProcessStdout && process.stdout.isTTY === true;
-
-/**
- * Provides a constructor for a Case Class.
- *
- * @since 2.0.0
- * @category constructors
- */
-const Error$1 = /*#__PURE__*/function () {
-  const plainArgsSymbol = /*#__PURE__*/Symbol.for("effect/Data/Error/plainArgs");
-  const O = {
-    BaseEffectError: class extends YieldableError {
-      constructor(args) {
-        super(args?.message, args?.cause ? {
-          cause: args.cause
-        } : undefined);
-        if (args) {
-          Object.assign(this, args);
-          // @effect-diagnostics-next-line floatingEffect:off
-          Object.defineProperty(this, plainArgsSymbol, {
-            value: args,
-            enumerable: false
-          });
-        }
-      }
-      toJSON() {
-        return {
-          ...this[plainArgsSymbol],
-          ...this
-        };
-      }
-    }
-  };
-  return O.BaseEffectError;
-}();
-/**
- * @since 2.0.0
- * @category constructors
- */
-const TaggedError = tag => {
-  const O = {
-    BaseEffectError: class extends Error$1 {
-      _tag = tag;
-    }
-  };
-  O.BaseEffectError.prototype.name = tag;
-  return O.BaseEffectError;
-};
-
-class FetchError extends TaggedError('FetchError') {
-}
-class NotFoundError extends TaggedError('NotFoundError') {
-}
-class ResponseTextError extends TaggedError('ResponseTextError') {
-    constructor(error) {
-        super(new Error(`Failed to read response text`, { cause: error }));
-    }
-}
-
-refined(isValidSVG, () => error('SVG data is malformed'));
-class BrandValidationError extends TaggedError('BrandValidationError') {
-    constructor(error, type) {
-        super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
-    }
-}
-function isValidSVG(svg) {
-    if (typeof svg !== 'string') {
-        return false;
-    }
-    try {
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(svg, 'image/svg+xml');
-        return doc.documentElement.nodeName === 'svg';
-    }
-    catch {
-        return false;
-    }
-}
-
-const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));display:inline-block;line-height:0;svg{display:block}svg>path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));height:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem))}}[size='sm'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.81rem + 0.26vw, 1.13rem));height:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.81rem + 0.26vw, 1.13rem))}}[size='md'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-md, clamp(1rem, 0.88rem + 0.52vw, 1.5rem));height:var(--lmvz-component-icon-size-md, clamp(1rem, 0.88rem + 0.52vw, 1.5rem))}}[size='lg'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.38rem + 0.52vw, 2rem));height:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.38rem + 0.52vw, 2rem))}}[size='inherit'].sc-lmvz-icon-h{svg{width:inherit;height: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';
-    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) {
-            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: 'f5c2f8025d0e9598d903e72770ebca6cad01961c', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
-    }
-    waitUntilVisible(callback, rootMargin = 50) {
-        {
-            callback();
-            return;
-        }
-    }
-    static get assetsDirs() { return ["../../assets/icons"]; }
     static get watchers() { return {
         "icon": [{
                 "loadIconPathData": 0
+            }],
+        "iconset": [{
+                "loadIconPathData": 0
             }]
     }; }
     static get style() { return lmvzIconCss(); }
@@ -10005,17 +6240,18 @@ class LmvzIcon extends ReactiveControllerHost {
             "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"], ["ariaLabel", "aria-label"]]
+        "$attrsToReflect$": [["icon", "icon"], ["weight", "weight"], ["size", "size"], ["iconset", "iconset"], ["ariaLabel", "aria-label"]]
     }; }
 }
 
-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('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .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, #c7c7c7);   --input-border-color-focus: var(--lmvz-semantic-color-status-on-selected, #0e7ab4);   --input-border-width: var(--lmvz-semantic-border-width-default, 1px);   --input-height: 48px;    --input-padding-x: 16px;    --label-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --input-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --helper-text-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --error-text-color: var(--lmvz-semantic-color-status-on-danger, #e52a31);    --label-floating-scale: 0.85;    --label-minimized-top: -6px;   --label-minimized-bg: var(--input-bg);   --label-minimized-padding-x: 4px;       --input-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%); } .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: 8px;  } [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: 2px solid var(--input-border-color-focus);   outline-offset: 2px; }  .input-container.sc-lmvz-input:has(input:focus-visible) .input-wrapper.sc-lmvz-input {   box-shadow: 0 0 0 3px rgb(0 86 214 / 20%); }  [error].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color); } [error].sc-lmvz-input-h:focus-within .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color);   outline-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: 14px;    font-family: Router, sans-serif;   font-weight: 400;   pointer-events: none;   transition: all 0.2s ease-out;   background-color: transparent;   padding: 0;   margin: 0;   line-height: normal;   white-space: nowrap; } label.floating.sc-lmvz-input {   top: 0;    transform: translateY(-50%) scale(0.85);    transform-origin: left top;   background-color: var(--label-minimized-bg);   padding: 0 var(--label-minimized-padding-x);   left: -2px;    color: var(--input-text-color);    font-weight: 500;  } .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: 14px;   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: 12px;    font-size: 12px;   color: var(--helper-text-color);   font-family: Router, sans-serif;   font-weight: 500;  } [role='alert'].sc-lmvz-input {   padding-top: 8px;   padding-left: 12px;   font-size: 12px;   color: var(--error-text-color);   font-family: Router, sans-serif;   font-weight: 500; } .sc-lmvz-input-s > lmvz-button {      --lmvz-button-padding: 4px; }`;
+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('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .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, #c7c7c7);   --input-border-color-focus: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --input-border-width: var(--lmvz-semantic-border-width-default, 1px);   --input-height: 48px;    --input-padding-x: 16px;    --label-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --input-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --helper-text-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --error-text-color: var(--lmvz-semantic-color-status-on-danger, #e52a31);    --label-floating-scale: 0.85;    --label-minimized-top: -6px;   --label-minimized-bg: var(--input-bg);   --label-minimized-padding-x: 4px;       --input-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%); } .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: 8px;  } [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: 2px solid var(--input-border-color-focus);   outline-offset: 2px; }  .input-container.sc-lmvz-input:has(input:focus-visible) .input-wrapper.sc-lmvz-input {   box-shadow: 0 0 0 3px rgb(0 86 214 / 20%); }  [error].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color); } [error].sc-lmvz-input-h:focus-within .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color);   outline-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: 14px;    font-family: Router, sans-serif;   font-weight: 400;   pointer-events: none;   transition: all 0.2s ease-out;   background-color: transparent;   padding: 0;   margin: 0;   line-height: normal;   white-space: nowrap; } label.floating.sc-lmvz-input {   top: 0;    transform: translateY(-50%) scale(0.85);    transform-origin: left top;   background-color: var(--label-minimized-bg);   padding: 0 var(--label-minimized-padding-x);   left: -2px;    color: var(--input-text-color);    font-weight: 500;  } .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: 14px;   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: 12px;    font-size: 12px;   color: var(--helper-text-color);   font-family: Router, sans-serif;   font-weight: 500;  } [role='alert'].sc-lmvz-input {   padding-top: 8px;   padding-left: 12px;   font-size: 12px;   color: var(--error-text-color);   font-family: Router, sans-serif;   font-weight: 500; } .sc-lmvz-input-s > lmvz-button {      --lmvz-button-padding: 4px; }`;
 
 let inputIdCounter = 0;
 class LmvzInput extends ReactiveControllerHost {
@@ -10173,9 +6409,9 @@ class LmvzInput extends ReactiveControllerHost {
     render() {
         const hasValue = Boolean(this.value);
         const shouldFloatLabel = hasValue || Boolean(this.placeholder);
-        return (hAsync("div", { key: '195e2c5046d48d01f4912993bde3c8d2b3a73d1d', class: classNames('input-container', {
+        return (hAsync("div", { key: '9de2e4dd202edc937e96ff6ebdc8d0270851c4ca', class: classNames('input-container', {
                 'interaction-filled': hasValue,
-            }) }, hAsync("div", { key: '66bc3deab063a309eefc0de5ebf7f54331c9190c', class: "input-wrapper" }, hAsync("slot", { key: 'fac318070421d526bb09ba0dd0efdecf8964d952', name: "before-input" }), hAsync("div", { key: '1945152dc010d571c5886f222332b057e89e496c', class: "label-input-group" }, hAsync("label", { key: 'd57392c2c83b1e5f362dd33fa9d060e570417f3f', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (hAsync("span", { key: '507603a50eb08f0f4f5e2b87b2550fe6b657c4d4', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), hAsync("input", { key: '0fe916fef48618331806142c0d3500d9e6dec9cb', 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: 'b415bedde58862e5bd7621f73a1d77bc478850a3', name: "after-input" })), hAsync("div", { key: 'bc0e07f5243417f4c632eb2f7976dc944fdbf17a', id: this.helperId, role: "status" }, this.helperText || null), hAsync("div", { key: '62e2267453b92edd47077b233cb231a1deecedc4', id: this.errorId, role: "alert" }, (this.showErrorMessage && this.errorMessage) || null)));
+            }) }, hAsync("div", { key: '0c9f92778e1c52dca13ed9175a09d757fc6eedc9', class: "input-wrapper" }, hAsync("slot", { key: '9cf29c45afdb127917a68ed6752faf3d50004c7d', name: "before-input" }), hAsync("div", { key: 'e7e6c54b6ee6db108ac3f8ddb676bb9fcf10517e', class: "label-input-group" }, hAsync("label", { key: '68eb29e585741971aae58c7693d011ba587f1c1b', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (hAsync("span", { key: '274d992a43c2de45af7172608fb1581c6ee771d2', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), hAsync("input", { key: 'a26b95dee9781e0e13db16d6e09681e36cab0230', 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: '5b77b87ba1da3b8e71c7f6825eecf2216a93e4f9', name: "after-input" })), hAsync("div", { key: 'cac334a1e88d4136e923ef1355196997bfe97099', id: this.helperId, role: "status" }, this.helperText || null), hAsync("div", { key: 'b3ea662fa0a57ed0d8c3f35e36aad6b2513af8ab', id: this.errorId, role: "alert" }, (this.showErrorMessage && this.errorMessage) || null)));
     }
     static get formAssociated() { return true; }
     static get watchers() { return {
@@ -10230,7 +6466,7 @@ class LmvzInput extends ReactiveControllerHost {
     }; }
 }
 
-const lmvzMenuitemCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-menuitem-h {   display: inline-flex;   flex-direction: row;   align-items: center;   justify-content: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   border-radius: var(--lmvz-semantic-border-radius-lg, 14px);   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router);   padding: var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)) var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   cursor: pointer;    --lmvz-menuitem-color: var(--lmvz-semantic-color-int-on-tertiary, #545454);   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);    background: var(--lmvz-menuitem-background);   color: var(--lmvz-menuitem-color); } .sc-lmvz-menuitem-h:hover {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); } .sc-lmvz-menuitem-h:active {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); } .sc-lmvz-menuitem-h:focus-visible {      z-index: 1; } [aria-expanded='true'].sc-lmvz-menuitem-h {   --lmvz-menuitem-background: var(--lmvz-semantic-color-status-selected, #f1f9fe);   --lmvz-menuitem-color: var(--lmvz-semantic-color-status-on-selected, #0e7ab4); }`;
+const lmvzMenuitemCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-menuitem-h {   display: inline-flex;   flex-direction: row;   align-items: center;   justify-content: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   border-radius: var(--lmvz-semantic-border-radius-lg, 14px);   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router);   padding: var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)) var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   cursor: pointer;    --lmvz-menuitem-color: var(--lmvz-semantic-color-int-on-tertiary, #545454);   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);    background: var(--lmvz-menuitem-background);   color: var(--lmvz-menuitem-color); } .sc-lmvz-menuitem-h:hover {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); } .sc-lmvz-menuitem-h:active {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); } .sc-lmvz-menuitem-h:focus-visible {      z-index: 1; } [aria-expanded='true'].sc-lmvz-menuitem-h {   --lmvz-menuitem-background: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --lmvz-menuitem-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4); }`;
 
 class LmvzMenuItem extends ReactiveControllerHost {
     get el() { return getElement(this); }
@@ -10253,7 +6489,7 @@ class LmvzMenuItem extends ReactiveControllerHost {
         this.addController(new ElementActivationController(this));
     }
     render() {
-        return (hAsync(Host, { key: '1a37d2873a29c713cf95c60070c8dcf045c9f8fc' }, hAsync("slot", { key: 'c6578bcfdb9f0cebad095d80f0ed63cf663bf91e', ref: (e) => (this.validationSlot = e) })));
+        return (hAsync(Host, { key: '510ac59b18468ce9c65b866ae2767185f1b3da92' }, hAsync("slot", { key: '7e032e0dab83f9bfbaa96ad2b78d8a5a58f978ab', ref: (e) => (this.validationSlot = e) })));
     }
     static get style() { return lmvzMenuitemCss(); }
     static get cmpMeta() { return {
@@ -10271,7 +6507,7 @@ class LmvzMenuItem extends ReactiveControllerHost {
 
 const chevronDownSvg = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTIwLjMzMzQgOC42NjY2M0wxMi4wMDAxIDE3TDMuNjY2NzUgOC42NjY2MyIgc3Ryb2tlPSJibGFjayIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+Cjwvc3ZnPgo=';
 
-const lmvzSelectCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-select-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);       --lmvz-internal-select-floating-label-top-offset: 0.375rem;    padding-top: var(--lmvz-internal-select-floating-label-top-offset);       --lmvz-select-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-select-bg: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-select-bg-hover: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-select-text-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-select-label-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-padding-x: var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --lmvz-select-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-select-height: 40px;   --lmvz-select-label-font-size: var(--lmvz-component-component-typography-body-sm-font-size, 0.75rem);   --lmvz-select-label-top-offset: calc(var(--lmvz-internal-select-floating-label-top-offset) * -1);   --lmvz-select-label-minimized-padding-x: 4px;   --lmvz-select-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%);   --lmvz-select-helper-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --lmvz-select-focus-color: var(--lmvz-semantic-color-status-on-selected, #0e7ab4);   --lmvz-select-error-color: var(--lmvz-semantic-color-status-on-danger, #e52a31); } .select-wrapper.sc-lmvz-select {   position: relative;   height: var(--lmvz-select-height); }  label.sc-lmvz-select {   position: absolute;   top: 50%;   left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-label-color);   line-height: normal;   white-space: nowrap;   pointer-events: none;   z-index: 2;   transform: translateY(-50%);   transform-origin: left top;   transition:     top 0.2s ease-out,     transform 0.2s ease-out,     opacity 0.2s ease-out,     padding 0.2s ease-out; } label.assistive-label.sc-lmvz-select {   opacity: 0;   padding: 0; } label.floating-label.sc-lmvz-select {   top: var(--lmvz-select-label-top-offset);   transform: translateY(0) scale(0.85);   left: calc(var(--lmvz-select-padding-x) - 2px);   background-color: var(--lmvz-select-bg);   padding: 0 var(--lmvz-select-label-minimized-padding-x);   opacity: 1;   font-weight: 500; } label.sc-lmvz-select > span[aria-hidden='true'].sc-lmvz-select, div[aria-hidden='true'].sc-lmvz-select > span.sc-lmvz-select:first-child > span[aria-hidden='true'].sc-lmvz-select {   color: var(--lmvz-select-error-color);   margin-left: 2px;   display: inline-block;   line-height: 0;   vertical-align: middle; }  div[aria-hidden].sc-lmvz-select {   display: flex;   align-items: center;   gap: var(--lmvz-select-gap);   height: 100%;   padding: 0 var(--lmvz-select-padding-x);   border-radius: var(--lmvz-select-radius);   background-color: var(--lmvz-select-bg);   cursor: pointer;   position: relative;   z-index: 1;   transition: background-color 0.15s ease; } .sc-lmvz-select-h:not([disabled]) .select-wrapper.sc-lmvz-select:hover div[aria-hidden].sc-lmvz-select {   background-color: var(--lmvz-select-bg-hover); } .select-wrapper.sc-lmvz-select:focus-within div[aria-hidden].sc-lmvz-select {   outline: 2px solid var(--lmvz-select-focus-color);   outline-offset: 2px; } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   flex: 1 0 0;   font-size: var(--lmvz-component-component-typography-body-md-font-size, 0.875rem);   font-weight: var(--lmvz-global-font-weight-500, 500);   color: var(--lmvz-select-text-color);   line-height: 1.4;   letter-spacing: var(--lmvz-component-body-md-letter-spacing, 0);   overflow: hidden;   text-overflow: ellipsis;   white-space: nowrap; } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:last-child {   flex-shrink: 0;   display: flex;   align-items: center;   justify-content: center; } img.sc-lmvz-select {   display: block;   width: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   height: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)); }  select.sc-lmvz-select {   appearance: none;   position: absolute;   inset: 0;   width: 100%;   height: 100%;   opacity: 0;   cursor: pointer;   z-index: 2;   border: none;   background: transparent;   margin: 0;   padding: 0; } [disabled].sc-lmvz-select-h .select-wrapper.sc-lmvz-select {   opacity: var(--lmvz-select-disabled-opacity);   pointer-events: none;   cursor: not-allowed; } [role='status'].sc-lmvz-select {   margin-top: 4px;   padding-left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-helper-color);   line-height: normal; }`;
+const lmvzSelectCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-select-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);       --lmvz-internal-select-floating-label-top-offset: 0.375rem;    padding-top: var(--lmvz-internal-select-floating-label-top-offset);       --lmvz-select-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-select-bg: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-select-bg-hover: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-select-text-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-select-label-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --lmvz-select-padding-x: var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --lmvz-select-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-select-height: 40px;   --lmvz-select-label-font-size: var(--lmvz-component-component-typography-body-sm-font-size, 0.75rem);   --lmvz-select-label-top-offset: calc(var(--lmvz-internal-select-floating-label-top-offset) * -1);   --lmvz-select-label-minimized-padding-x: 4px;   --lmvz-select-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%);   --lmvz-select-helper-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --lmvz-select-focus-color: var(--lmvz-semantic-color-status-on-active, #0e7ab4);   --lmvz-select-error-color: var(--lmvz-semantic-color-status-on-danger, #e52a31); } .select-wrapper.sc-lmvz-select {   position: relative;   height: var(--lmvz-select-height); }  label.sc-lmvz-select {   position: absolute;   top: 50%;   left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-label-color);   line-height: normal;   white-space: nowrap;   pointer-events: none;   z-index: 2;   transform: translateY(-50%);   transform-origin: left top;   transition:     top 0.2s ease-out,     transform 0.2s ease-out,     opacity 0.2s ease-out,     padding 0.2s ease-out; } label.assistive-label.sc-lmvz-select {   opacity: 0;   padding: 0; } label.floating-label.sc-lmvz-select {   top: var(--lmvz-select-label-top-offset);   transform: translateY(0) scale(0.85);   left: calc(var(--lmvz-select-padding-x) - 2px);   background-color: var(--lmvz-select-bg);   padding: 0 var(--lmvz-select-label-minimized-padding-x);   opacity: 1;   font-weight: 500; } label.sc-lmvz-select > span[aria-hidden='true'].sc-lmvz-select, div[aria-hidden='true'].sc-lmvz-select > span.sc-lmvz-select:first-child > span[aria-hidden='true'].sc-lmvz-select {   color: var(--lmvz-select-error-color);   margin-left: 2px;   display: inline-block;   line-height: 0;   vertical-align: middle; }  div[aria-hidden].sc-lmvz-select {   display: flex;   align-items: center;   gap: var(--lmvz-select-gap);   height: 100%;   padding: 0 var(--lmvz-select-padding-x);   border-radius: var(--lmvz-select-radius);   background-color: var(--lmvz-select-bg);   cursor: pointer;   position: relative;   z-index: 1;   transition: background-color 0.15s ease; } .sc-lmvz-select-h:not([disabled]) .select-wrapper.sc-lmvz-select:hover div[aria-hidden].sc-lmvz-select {   background-color: var(--lmvz-select-bg-hover); } .select-wrapper.sc-lmvz-select:focus-within div[aria-hidden].sc-lmvz-select {   outline: 2px solid var(--lmvz-select-focus-color);   outline-offset: 2px; } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:first-child {   flex: 1 0 0;   font-size: var(--lmvz-component-component-typography-body-md-font-size, 0.875rem);   font-weight: var(--lmvz-global-font-weight-500, 500);   color: var(--lmvz-select-text-color);   line-height: 1.4;   letter-spacing: var(--lmvz-component-body-md-letter-spacing, 0);   overflow: hidden;   text-overflow: ellipsis;   white-space: nowrap; } div[aria-hidden].sc-lmvz-select > span.sc-lmvz-select:last-child {   flex-shrink: 0;   display: flex;   align-items: center;   justify-content: center; } img.sc-lmvz-select {   display: block;   width: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   height: var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem)); }  select.sc-lmvz-select {   appearance: none;   position: absolute;   inset: 0;   width: 100%;   height: 100%;   opacity: 0;   cursor: pointer;   z-index: 2;   border: none;   background: transparent;   margin: 0;   padding: 0; } [disabled].sc-lmvz-select-h .select-wrapper.sc-lmvz-select {   opacity: var(--lmvz-select-disabled-opacity);   pointer-events: none;   cursor: not-allowed; } [role='status'].sc-lmvz-select {   margin-top: 4px;   padding-left: var(--lmvz-select-padding-x);   font-size: var(--lmvz-select-label-font-size);   color: var(--lmvz-select-helper-color);   line-height: normal; }`;
 
 let selectIdCounter = 0;
 class LmvzSelect extends ReactiveControllerHost {
@@ -10323,7 +6559,7 @@ class LmvzSelect extends ReactiveControllerHost {
     render() {
         const hasValue = this.hasValue;
         const shouldShowLabel = hasValue;
-        return (hAsync(Host, { key: '7d1abb943f79e90451b43c9221801b80a2f61346' }, hAsync("div", { key: 'ded3e45246ab38e89d444c59239cdc63a2c4d4fc', class: "select-wrapper" }, hAsync("label", { key: 'cb68ff79976c2fb55d4cc827f9e90ba2597a8a43', htmlFor: this.selectId, class: shouldShowLabel ? 'floating-label' : 'assistive-label' }, this.label, this.required && shouldShowLabel && hAsync("span", { key: 'ab77eaea1645b95d90f00ffb609bbd7a1704f7bc', "aria-hidden": "true" }, " *")), hAsync("div", { key: '45cee00478a6cc31c10dddf69d8e6687fc8f440d', "aria-hidden": "true" }, hAsync("span", { key: '0c5d425ea8843234aa6abd94a207377e2a675686' }, hasValue ? this.selectedLabel : this.label, this.required && !hasValue && hAsync("span", { key: 'ebef5322371ee0253b50dd801b80cbb6402c067a', "aria-hidden": "true" }, " *")), hAsync("span", { key: 'a12d31dc29563444f728133f181b48914d31705b' }, hAsync("img", { key: 'dd3f175d1ca2b9ccc6c2bfa2075e5da62016a896', src: chevronDownSvg, alt: "" }))), hAsync("select", { key: 'a196f3b824177d1b45971c38341bf6a2939dda82', 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: '536cc559def0e9ffa4b2150693ece9a597c238d1', value: "", disabled: true, selected: true, hidden: true }), hAsync("slot", { key: 'ad9fed96b9f8c1d8257511bb1d5ab5ee756973ce' }))), this.helperText && hAsync("div", { key: '4723b44d781c900be5aae7ece2a0be04b6c744b9', role: "status" }, this.helperText)));
+        return (hAsync(Host, { key: '7f4650d5971bb93dba48385df734e6b7a0b4f7eb' }, hAsync("div", { key: '79d6234cd15f64c8bff787d715107e7e86145333', class: "select-wrapper" }, hAsync("label", { key: '14d93469c6d309b68427ff7bfc2bd531c8f0ecf6', htmlFor: this.selectId, class: shouldShowLabel ? 'floating-label' : 'assistive-label' }, this.label, this.required && shouldShowLabel && hAsync("span", { key: 'c8be809e09d768d6f73ccccdfbf0bf495869ac72', "aria-hidden": "true" }, " *")), hAsync("div", { key: '1db5d44b44100342a4ca5feff648b61a0bdadb1a', "aria-hidden": "true" }, hAsync("span", { key: '3fdc95aab9997a10f4ba42dabc3758aea0797a22' }, hasValue ? this.selectedLabel : this.label, this.required && !hasValue && hAsync("span", { key: '11aef8194551059130b6be5351587219a1e80f00', "aria-hidden": "true" }, " *")), hAsync("span", { key: '8fc52ff3e46d7b52d8d5069a74ebf7bb0d981081' }, hAsync("img", { key: '129dd4038772eba9313e1e322866c70408f4e2ad', src: chevronDownSvg, alt: "" }))), hAsync("select", { key: '6eb6cf496e60b3c1bd9556e596cbef34d4da5a09', 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: '70d660e0bc7e4c127234ce77decf35d6fea7fe8d', value: "", disabled: true, selected: true, hidden: true }), hAsync("slot", { key: 'e6cbc238c9c0cf8e8c31d0347a1f621272a94ca6' }))), this.helperText && hAsync("div", { key: '432d405ee7338da46509ff207599b882a19ea44e', role: "status" }, this.helperText)));
     }
     static get watchers() { return {
         "value": [{