@statistikzh/leu 0.24.0 → 0.24.2

package/dist/Range.js

@@ -1,7 +1,9 @@
 import { _ as __decorate } from './_tslib-CNEFicEt.js';
 import { css, nothing, html } from 'lit';
-import { property } from 'lit/decorators.js';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { property, query } from 'lit/decorators.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
+import { i as isNumber, c as clamp } from './utils-DBGsNSJW.js';
 
 var css_248z = css`:host {
   --range-color: var(--leu-color-black-40);
@@ -253,6 +255,10 @@ const RANGE_LABELS = ["Von", "Bis"];
 class LeuRange extends LeuElement {
     constructor() {
         super(...arguments);
+        /**
+         * The default value of the range slider.
+         * String input is parsed as a comma-separated list of numbers.
+         */
         this.defaultValue = [50];
         /**
          * The minimum value of the range slider.
@@ -304,90 +310,127 @@ class LeuRange extends LeuElement {
          * Is ignored if a custom valueFormatter is provided.
          */
         this.suffix = "";
-    }
-    updated() {
-        this._updateStyles();
-    }
-    get _inputs() {
-        return Array.from(this.shadowRoot.querySelectorAll("input"));
-    }
-    _updateStyles() {
-        const normalizedRange = this._getNormalizedRange();
-        this.style.setProperty("--low", normalizedRange[0].toString());
-        this.style.setProperty("--high", normalizedRange[1].toString());
-        const inputs = this.multiple
-            ? [this._getBaseInput(), this._getGhostInput()]
-            : [this._getBaseInput()];
-        inputs.forEach((input) => {
-            const output = this.shadowRoot.querySelector(`.output[for=${input.id}]`);
-            const normalizedValue = this._getNormalizedValue(input.valueAsNumber);
-            output.style.setProperty("--value", normalizedValue.toString());
-            output.value = this.formatValue(input.valueAsNumber);
-        });
-    }
-    get value() {
-        return this._inputs.map((input) => input.value).join(",");
+        this._value = this.defaultValue.map((v) => this.clampAndRoundValue(v));
     }
     /**
-     * Sets the value of the underlying input element(s).
-     * The value has to be an array if "multiple" range is used.
-     * Otherwise it has to be a string.
+     * The value of the range slider.
+     * String input is parsed as a comma-separated list of numbers.
+     * In multiple mode, if only a single value is provided, the second handle will be set to the minimum value.
+     * In single mode, only the first value will be used.
      */
     set value(value) {
-        if (this.multiple && Array.isArray(value)) {
-            const inputs = this._inputs;
-            value.forEach((v, i) => {
-                inputs[i].value = v;
-            });
-            this._updateStyles();
+        let nextValue = [];
+        if (typeof value === "string") {
+            nextValue = value
+                .split(",")
+                .map((v) => Number(v.trim()))
+                .filter(isNumber);
+        }
+        else if (isNumber(value)) {
+            nextValue = [value];
+        }
+        else if (Array.isArray(value)) {
+            nextValue = value.map((v) => Number(v)).filter(isNumber);
+        }
+        if (nextValue.length === 0) {
+            return;
         }
-        else if (!this.multiple) {
-            this._getBaseInput().value = value;
-            this._updateStyles();
+        // In multiple mode, we need to ensure that we always have two values.
+        // `min` is a fallback for the second value.
+        if (this.multiple && nextValue.length === 1) {
+            nextValue.unshift(this.min);
         }
+        this._value = nextValue
+            .slice(0, this.multiple ? 2 : 1)
+            .map((v) => this.clampAndRoundValue(v));
+    }
+    get value() {
+        return this._value.join(",");
     }
     get valueAsArray() {
-        return this._inputs.map((input) => input.valueAsNumber);
+        return this._value.slice();
     }
     get valueLow() {
-        const inputs = this._inputs;
-        if (this.multiple) {
-            return inputs.map((input) => input.valueAsNumber).sort((a, b) => a - b)[0];
-        }
-        return inputs[0].value;
+        return Math.min(...this._value);
     }
     get valueHigh() {
-        const inputs = this._inputs;
-        if (this.multiple) {
-            return inputs.map((input) => input.valueAsNumber).sort((a, b) => a - b)[1];
+        return Math.max(...this._value);
+    }
+    updated() {
+        this.updateStyles();
+    }
+    willUpdate(changedProperties) {
+        // Reflect defaultValue changes to the value property
+        // to ensure backwards compatibility with previous versions
+        if (changedProperties.has("defaultValue")) {
+            this.value = this.defaultValue.map((v) => this.clampAndRoundValue(v));
+        }
+        if (changedProperties.has("min") ||
+            changedProperties.has("max") ||
+            changedProperties.has("step")) {
+            this._value = this._value.map((v) => this.clampAndRoundValue(v));
+        }
+        if (changedProperties.has("multiple") && this.multiple) {
+            // When switching to multiple mode, ensure that we have two values
+            if (this._value.length === 1) {
+                this._value = [this.min, this._value[0]];
+            }
+        }
+        else if (changedProperties.has("multiple") && !this.multiple) {
+            // When switching to single mode, keep only the lower value
+            this._value = [this.valueLow];
         }
-        return inputs[0].value;
     }
-    _getBaseInput() {
-        return this.shadowRoot.querySelector(".range--base");
+    updateStyles() {
+        const normalizedRange = this.getNormalizedRange();
+        this.container?.style.setProperty("--low", normalizedRange[0].toString());
+        this.container?.style.setProperty("--high", normalizedRange[1].toString());
+        const inputs = this.multiple
+            ? [this.inputBase, this.inputGhost]
+            : [this.inputBase];
+        inputs.forEach((input) => {
+            const output = input.id === "input-base" ? this.outputBase : this.outputGhost;
+            const normalizedValue = this.getNormalizedValue(input.valueAsNumber);
+            output.style.setProperty("--value", normalizedValue.toString());
+            output.value = this.formatValue(input.valueAsNumber);
+        });
     }
-    _getGhostInput() {
-        return this.shadowRoot.querySelector(".range--ghost");
+    clampAndRoundValue(value) {
+        const clampedValue = clamp(value, this.min, this.max);
+        const roundedValue = Math.round((clampedValue - this.min) / this.step) * this.step + this.min;
+        return roundedValue;
     }
-    _handleInput(_index, _e) {
-        this._updateStyles();
+    handleInput(e) {
+        e.stopPropagation();
+        if (this.multiple) {
+            this.value = [this.inputBase.valueAsNumber, this.inputGhost.valueAsNumber];
+        }
+        else {
+            this.value = [this.inputBase.valueAsNumber];
+        }
+        this.dispatchEvent(new CustomEvent("input", {
+            composed: true,
+            bubbles: true,
+            detail: { value: this.value, valueAsArray: this.valueAsArray },
+        }));
     }
-    _getNormalizedValue(value) {
+    getNormalizedValue(value) {
         return (value - this.min) / (this.max - this.min);
     }
-    _getNormalizedRange() {
+    getNormalizedRange() {
         if (this.multiple) {
             return this.valueAsArray
-                .map((value) => this._getNormalizedValue(value))
+                .map((value) => this.getNormalizedValue(value))
                 .sort((a, b) => a - b);
         }
-        return [0, this._getNormalizedValue(this.valueAsArray[0])];
+        return [0, this.getNormalizedValue(this.valueAsArray[0])];
     }
     /**
-     * Determine if the "click" (pointer event) is closer the
-     * the value of the other input element. Swap the values if this is the case.
+     * This event handler is only applied to the "base" input element and only when in "multiple" mode.
+     * It handles pointer events on the *track* and the thumb.
+     * This method determines if the interaction was closer to the base or the ghost input.
      */
-    _handlePointerDown(e) {
+    handlePointerDown(e) {
         const clickValue = this.min + ((this.max - this.min) * e.offsetX) / this.offsetWidth;
         const middleValue = (this.valueAsArray[0] + this.valueAsArray[1]) / 2;
         if ((e.target.valueAsNumber === this.valueLow) ===
@@ -396,8 +439,7 @@ class LeuRange extends LeuElement {
              * As the pointerdown event is fired before the input event, we first overwrite the value
              * of the input element that was not clicked on. The active input element will update itself.
              */
-            // this._value = [e.target.valueAsNumber, e.target.valueAsNumber]
-            this._getGhostInput().value = e.target.value;
+            this.inputGhost.value = e.target.value;
         }
     }
     formatValue(value) {
@@ -413,18 +455,19 @@ class LeuRange extends LeuElement {
         return html `<div class="ticks">
       ${Array.from({ length: (this.max - this.min) / this.step + 1 }, (_, i) => this.min + i * this.step).map((tick) => html `<span
             class="tick"
-            style="left: ${this._getNormalizedValue(tick) * 100}%"
+            style="left: ${this.getNormalizedValue(tick) * 100}%"
           ></span>`)}
     </div>`;
     }
     render() {
         const inputs = this.multiple ? ["base", "ghost"] : ["base"];
-        const { multiple, disabled, label, defaultValue } = this;
+        const { multiple, disabled, label, valueAsArray } = this;
         return html `
       <div
+        id="container"
         class="container"
-        role=${multiple ? "group" : undefined}
-        aria-labelledby=${multiple ? "group-label" : undefined}
+        role=${ifDefined(multiple ? "group" : undefined)}
+        aria-labelledby=${ifDefined(multiple ? "group-label" : undefined)}
       >
         ${multiple
             ? html `<span id="group-label" class="label">${label}</span>`
@@ -433,15 +476,15 @@ class LeuRange extends LeuElement {
           ${inputs.map((type, index) => html `<output
                 class="output"
                 for="input-${type}"
-                value=${this.formatValue(defaultValue[index])}
+                value=${this.formatValue(valueAsArray[index])}
               ></output>`)}
         </div>
         <div class="inputs">
           ${inputs.map((type, index) => html `
               <input
-                @input=${(e) => this._handleInput(index, e)}
+                @input=${this.handleInput}
                 @pointerdown=${multiple && !disabled && index === 0
-            ? this._handlePointerDown
+            ? this.handlePointerDown
             : undefined}
                 type="range"
                 class="range range--${type}"
@@ -450,9 +493,9 @@ class LeuRange extends LeuElement {
                 min=${this.min}
                 max=${this.max}
                 step=${this.step}
-                aria-label=${multiple ? RANGE_LABELS[index] : undefined}
+                aria-label=${ifDefined(multiple ? RANGE_LABELS[index] : undefined)}
                 ?disabled=${disabled}
-                .value=${defaultValue[index].toString()}
+                .value=${valueAsArray[index].toString()}
               />
             `)}
           ${this.renderTicks()}
@@ -477,7 +520,11 @@ LeuRange.shadowRootOptions = {
     delegatesFocus: true,
 };
 __decorate([
-    property({ converter: defaultValueConverter, attribute: "value" })
+    property({
+        converter: defaultValueConverter,
+        attribute: "value",
+        reflect: true,
+    })
 ], LeuRange.prototype, "defaultValue", void 0);
 __decorate([
     property({ type: Number, reflect: true })
@@ -518,5 +565,23 @@ __decorate([
 __decorate([
     property({ attribute: false })
 ], LeuRange.prototype, "valueFormatter", void 0);
+__decorate([
+    property({ attribute: false })
+], LeuRange.prototype, "value", null);
+__decorate([
+    query("#container")
+], LeuRange.prototype, "container", void 0);
+__decorate([
+    query("#input-base")
+], LeuRange.prototype, "inputBase", void 0);
+__decorate([
+    query("#input-ghost")
+], LeuRange.prototype, "inputGhost", void 0);
+__decorate([
+    query("output[for=input-base]")
+], LeuRange.prototype, "outputBase", void 0);
+__decorate([
+    query("output[for=input-ghost]")
+], LeuRange.prototype, "outputGhost", void 0);
 
 export { LeuRange };

package/dist/ScrollTop.js

@@ -2,55 +2,49 @@ import { _ as __decorate } from './_tslib-CNEFicEt.js';
 import { css, html } from 'lit';
 import { classMap } from 'lit/directives/class-map.js';
 import { state } from 'lit/decorators.js';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 import { LeuButton } from './Button.js';
 import { LeuIcon } from './Icon.js';
+import { t as throttle } from './utils-DBGsNSJW.js';
 import 'lit/directives/if-defined.js';
 import './hasSlotController-Bm2tipvG.js';
 
-/**
- * Return a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked.
- * @param {Function} func - Your function
- * @param {Number} timeout - Default is 500 ms
- * @returns {Function} - Your function wrapped in a timeout function
- */
-/**
- * Return a throttled function that only invokes func at most once per every wait milliseconds.
- * @param {Function} func - Your function
- * @param {Number} timeout - Default is 500 ms
- * @returns {Function} - Your function wrapped in a timeout function
- */
-const throttle = function throttle(func, timeout = 500) {
-    let timer = null;
-    return (...args) => {
-        if (timer === null) {
-            func(...args);
-            timer = setTimeout(() => {
-                timer = null;
-            }, timeout);
-        }
-    };
-};
-
 var css_248z = css`.scroll-top {
   overflow: hidden;
   position: fixed;
+  z-index: var(--leu-z-index-scroll-top);
+
+  --_space: 1.5rem;
   right: 1.5rem;
-  z-index: 1099;
-  bottom: 8.125rem;
+  right: var(--_space);
+  bottom: 1.5rem;
+  bottom: var(--_space);
 
   /* show */
-  height: 50px;
+  height: 3rem;
   pointer-events: auto;
   transition: height, bottom 0.9s, 0.6s ease;
 }
-
+@media (min-width: 600px) {
+.scroll-top {
+    --_space: 2rem;
+}
+  }
+@media (min-width: 1024px) {
+.scroll-top {
+    --_space: 2.5rem;
+}
+  }
+@media (min-width: 1280px) {
+.scroll-top {
+    --_space: 3rem;
+}
+  }
 .hide {
   height: 0;
   pointer-events: none;
   transition: height, top 0.9s, 0.6s ease;
 }
-
 @keyframes hide-animation {
   0% {
     transform: rotate(0deg);
@@ -60,7 +54,6 @@ var css_248z = css`.scroll-top {
     transform: rotate(90deg);
   }
 }
-
 .hide leu-button {
   animation-name: hide-animation;
   animation-duration: 0.45s;

package/dist/Select.js

@@ -2,7 +2,7 @@ import { css, nothing, html } from 'lit';
 import { classMap } from 'lit/directives/class-map.js';
 import { createRef, ref } from 'lit/directives/ref.js';
 import { ifDefined } from 'lit/directives/if-defined.js';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 import { H as HasSlotController } from './hasSlotController-Bm2tipvG.js';
 import { LeuButton } from './Button.js';
 import { LeuMenu } from './Menu.js';

package/dist/Spinner.js

@@ -1,5 +1,5 @@
 import { css, html } from 'lit';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 
 var css_248z = css`@keyframes leu-spinner-rotate {
   from {

package/dist/Table.js

@@ -1,7 +1,7 @@
 import { nothing, noChange, css, html } from 'lit';
 import { classMap } from 'lit/directives/class-map.js';
 import { createRef, ref } from 'lit/directives/ref.js';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 import { directive, Directive, PartType } from 'lit/directive.js';
 import { LeuIcon } from './Icon.js';
 import { LeuPagination } from './Pagination.js';

package/dist/Tag.js

@@ -1,7 +1,7 @@
 import { _ as __decorate } from './_tslib-CNEFicEt.js';
 import { css, html } from 'lit';
 import { property } from 'lit/decorators.js';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 
 var css_248z = css`:host {
   /* --tag-font-regular: var(--leu-font-family-regular);

package/dist/VisuallyHidden.js

@@ -1,5 +1,5 @@
 import { css, html } from 'lit';
-import { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+import { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 
 var css_248z = css`:host {
   clip: rect(0 0 0 0);

package/dist/components/range/Range.d.ts

@@ -1,5 +1,6 @@
-import { nothing } from "lit";
+import { nothing, PropertyValues } from "lit";
 import { LeuElement } from "../../lib/LeuElement.js";
+type InternalRangeValue = [number, number] | [number];
 /**
  * @tagname leu-range
  */
@@ -13,6 +14,10 @@ export declare class LeuRange extends LeuElement {
         customElements?: CustomElementRegistry;
         registry?: CustomElementRegistry;
     };
+    /**
+     * The default value of the range slider.
+     * String input is parsed as a comma-separated list of numbers.
+     */
     defaultValue: number[];
     /**
      * The minimum value of the range slider.
@@ -69,35 +74,43 @@ export declare class LeuRange extends LeuElement {
      * If provided, the prefix and suffix properties will be ignored.
      */
     valueFormatter?: (value: number) => string;
-    updated(): void;
-    protected get _inputs(): HTMLInputElement[];
-    protected _updateStyles(): void;
-    get value(): string | Array<string>;
+    protected _value: InternalRangeValue;
     /**
-     * Sets the value of the underlying input element(s).
-     * The value has to be an array if "multiple" range is used.
-     * Otherwise it has to be a string.
+     * The value of the range slider.
+     * String input is parsed as a comma-separated list of numbers.
+     * In multiple mode, if only a single value is provided, the second handle will be set to the minimum value.
+     * In single mode, only the first value will be used.
      */
-    set value(value: string | Array<string>);
-    get valueAsArray(): number[];
-    get valueLow(): string | number;
-    get valueHigh(): string | number;
-    protected _getBaseInput(): HTMLInputElement;
-    protected _getGhostInput(): HTMLInputElement;
-    protected _handleInput(_index: number, _e: InputEvent & {
+    set value(value: string | number | Array<string | number>);
+    get value(): string;
+    get valueAsArray(): InternalRangeValue;
+    get valueLow(): number;
+    get valueHigh(): number;
+    protected container: HTMLDivElement;
+    protected inputBase: HTMLInputElement;
+    protected inputGhost: HTMLInputElement | null;
+    protected outputBase: HTMLOutputElement;
+    protected outputGhost: HTMLOutputElement | null;
+    updated(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected updateStyles(): void;
+    protected clampAndRoundValue(value: number): number;
+    protected handleInput(e: Event & {
         target: HTMLInputElement;
     }): void;
-    protected _getNormalizedValue(value: number): number;
-    protected _getNormalizedRange(): number[];
+    protected getNormalizedValue(value: number): number;
+    protected getNormalizedRange(): number[];
     /**
-     * Determine if the "click" (pointer event) is closer the
-     * the value of the other input element. Swap the values if this is the case.
+     * This event handler is only applied to the "base" input element and only when in "multiple" mode.
+     * It handles pointer events on the *track* and the thumb.
+     * This method determines if the interaction was closer to the base or the ghost input.
      */
-    protected _handlePointerDown(e: PointerEvent & {
+    protected handlePointerDown(e: PointerEvent & {
         target: HTMLInputElement;
     }): void;
     protected formatValue(value: number): string;
     protected renderTicks(): typeof nothing | import("lit-html").TemplateResult<1>;
     render(): import("lit-html").TemplateResult<1>;
 }
+export {};
 //# sourceMappingURL=Range.d.ts.map

package/dist/components/range/Range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Range.d.ts","sourceRoot":"","sources":["../../../src/components/range/Range.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,KAAK,CAAA;AAInC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAapD;;GAEG;AACH,qBAAa,QAAS,SAAQ,UAAU;IACtC,MAAM,CAAC,MAAM,iCAA8B;IAE3C,MAAM,CAAC,iBAAiB;;;;;;;MAGvB;IAGD,YAAY,WAAO;IAEnB;;OAEG;IAEH,GAAG,EAAE,MAAM,CAAI;IAEf;;OAEG;IAEH,GAAG,EAAE,MAAM,CAAM;IAEjB;;OAEG;IAEH,IAAI,EAAE,MAAM,CAAI;IAGhB,IAAI,EAAE,MAAM,CAAK;IAEjB;;OAEG;IAEH,KAAK,EAAE,MAAM,CAAK;IAElB;;;;OAIG;IAEH,SAAS,EAAE,OAAO,CAAQ;IAE1B;;OAEG;IAEH,QAAQ,EAAE,OAAO,CAAQ;IAEzB;;OAEG;IAEH,QAAQ,EAAE,OAAO,CAAQ;IAEzB;;;OAGG;IAEH,SAAS,EAAE,OAAO,CAAQ;IAE1B;;OAEG;IAEH,eAAe,EAAE,OAAO,CAAQ;IAEhC;;;OAGG;IAEH,MAAM,EAAE,MAAM,CAAK;IAEnB;;;OAGG;IAEH,MAAM,EAAE,MAAM,CAAK;IAEnB;;;OAGG;IAEH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAE1C,OAAO;IAIP,SAAS,KAAK,OAAO,uBAIpB;IAED,SAAS,CAAC,aAAa;IAmBvB,IAAI,KAAK,IASQ,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAPtC;IAED;;;;OAIG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,EAYtC;IAED,IAAI,YAAY,aAEf;IAED,IAAI,QAAQ,oBAQX;IAED,IAAI,SAAS,oBAQZ;IAED,SAAS,CAAC,aAAa;IAIvB,SAAS,CAAC,cAAc;IAIxB,SAAS,CAAC,YAAY,CACpB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,UAAU,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE;IAK/C,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM;IAI3C,SAAS,CAAC,mBAAmB;IAU7B;;;OAGG;IACH,SAAS,CAAC,kBAAkB,CAAC,CAAC,EAAE,YAAY,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE;IAkB3E,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAQnC,SAAS,CAAC,WAAW;IAmBrB,MAAM;CA4DP"}
+{"version":3,"file":"Range.d.ts","sourceRoot":"","sources":["../../../src/components/range/Range.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAKnD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAGpD,KAAK,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AAarD;;GAEG;AACH,qBAAa,QAAS,SAAQ,UAAU;IACtC,MAAM,CAAC,MAAM,iCAA8B;IAE3C,MAAM,CAAC,iBAAiB;;;;;;;MAGvB;IAED;;;OAGG;IAMH,YAAY,WAAO;IAEnB;;OAEG;IAEH,GAAG,EAAE,MAAM,CAAI;IAEf;;OAEG;IAEH,GAAG,EAAE,MAAM,CAAM;IAEjB;;OAEG;IAEH,IAAI,EAAE,MAAM,CAAI;IAGhB,IAAI,EAAE,MAAM,CAAK;IAEjB;;OAEG;IAEH,KAAK,EAAE,MAAM,CAAK;IAElB;;;;OAIG;IAEH,SAAS,EAAE,OAAO,CAAQ;IAE1B;;OAEG;IAEH,QAAQ,EAAE,OAAO,CAAQ;IAEzB;;OAEG;IAEH,QAAQ,EAAE,OAAO,CAAQ;IAEzB;;;OAGG;IAEH,SAAS,EAAE,OAAO,CAAQ;IAE1B;;OAEG;IAEH,eAAe,EAAE,OAAO,CAAQ;IAEhC;;;OAGG;IAEH,MAAM,EAAE,MAAM,CAAK;IAEnB;;;OAGG;IAEH,MAAM,EAAE,MAAM,CAAK;IAEnB;;;OAGG;IAEH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAE1C,SAAS,CAAC,MAAM,EAAE,kBAAkB,CAEb;IAEvB;;;;;OAKG;IACH,IACI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EA2BxD;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,YAAY,IAAI,kBAAkB,CAErC;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAGD,SAAS,CAAC,SAAS,EAAE,cAAc,CAAA;IAGnC,SAAS,CAAC,SAAS,EAAE,gBAAgB,CAAA;IAGrC,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAG7C,SAAS,CAAC,UAAU,EAAE,iBAAiB,CAAA;IAGvC,SAAS,CAAC,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAE/C,OAAO;IAIP,SAAS,CAAC,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IA8BnE,SAAS,CAAC,YAAY;IAkBtB,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM;IAQ1C,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE;IAkB7D,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM;IAI1C,SAAS,CAAC,kBAAkB;IAU5B;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,CAAC,CAAC,EAAE,YAAY,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE;IAiB1E,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAQnC,SAAS,CAAC,WAAW;IAmBrB,MAAM;CA+DP"}

package/dist/components/range/stories/range.stories.d.ts

@@ -13,6 +13,7 @@ declare const _default: {
     };
     args: {
         label: string;
+        oninput: import("@storybook/addon-actions").HandlerFunction;
     };
 };
 export default _default;

package/dist/components/range/stories/range.stories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"range.stories.d.ts","sourceRoot":"","sources":["../../../../src/components/range/stories/range.stories.ts"],"names":[],"mappings":"AAIA,OAAO,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,0BAA0B,CAAA;AAEjC,KAAK,SAAS,GAAG,QAAQ,CAAA;;;;;;;;;;;;;;AAGzB,wBAY2B;AAsB3B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA;AAED,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;CAQvB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA;AAED,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;CAUjB,CAAA;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;CAUlB,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;gCAQA,MAAM;;;;;;;;;;;;;;;;CAEjC,CAAA;AAED,iBAAS,gBAAgB,CAAC,IAAI,EAAE,SAAS,wCAuDxC;AAED,eAAO,MAAM,QAAQ;;;;;;;;CAQpB,CAAA"}
+{"version":3,"file":"range.stories.d.ts","sourceRoot":"","sources":["../../../../src/components/range/stories/range.stories.ts"],"names":[],"mappings":"AAKA,OAAO,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,0BAA0B,CAAA;AAEjC,KAAK,SAAS,GAAG,QAAQ,CAAA;;;;;;;;;;;;;;;AAGzB,wBAa2B;AAuB3B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA;AAED,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;CAQvB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA;AAED,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;CAUjB,CAAA;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;CAUlB,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;gCAQA,MAAM;;;;;;;;;;;;;;;;CAEjC,CAAA;AAED,iBAAS,gBAAgB,CAAC,IAAI,EAAE,SAAS,wCAuDxC;AAED,eAAO,MAAM,QAAQ;;;;;;;;CAQpB,CAAA"}

package/dist/index.js

@@ -29,7 +29,7 @@ export { LeuSpinner } from './Spinner.js';
 export { LeuTable } from './Table.js';
 export { LeuTag } from './Tag.js';
 export { LeuVisuallyHidden } from './VisuallyHidden.js';
-export { L as LeuElement } from './LeuElement-BfbOWTGZ.js';
+export { L as LeuElement } from './LeuElement-BfXSO7MN.js';
 import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/static-html.js';
@@ -41,4 +41,5 @@ import './Chip.js';
 import 'lit/directives/ref.js';
 import 'lit/directives/live.js';
 import '@floating-ui/dom';
+import './utils-DBGsNSJW.js';
 import 'lit/directive.js';

package/dist/leu-accordion.js

@@ -3,7 +3,7 @@ import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/static-html.js';
 import 'lit/decorators.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 
 LeuAccordion.define("leu-accordion");
 

package/dist/leu-button-group.js

@@ -1,6 +1,6 @@
 import { LeuButtonGroup } from './ButtonGroup.js';
 import 'lit';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import './Button.js';
 import './_tslib-CNEFicEt.js';
 import 'lit/directives/class-map.js';

package/dist/leu-button.js

@@ -5,7 +5,7 @@ import 'lit/directives/class-map.js';
 import 'lit/directives/if-defined.js';
 import 'lit/decorators.js';
 import './Icon.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import './hasSlotController-Bm2tipvG.js';
 
 LeuButton.define("leu-button");

package/dist/leu-chart-wrapper.js

@@ -2,7 +2,7 @@ import { LeuChartWrapper } from './ChartWrapper.js';
 import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/decorators.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import './hasSlotController-Bm2tipvG.js';
 import './Spinner.js';
 

package/dist/leu-checkbox-group.js

@@ -3,7 +3,7 @@ import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/directives/class-map.js';
 import 'lit/decorators.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import './Checkbox.js';
 import './Icon.js';
 

package/dist/leu-checkbox.js

@@ -2,7 +2,7 @@ import { LeuCheckbox } from './Checkbox.js';
 import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/decorators.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import './Icon.js';
 
 LeuCheckbox.define("leu-checkbox");

package/dist/leu-chip-group.js

@@ -2,7 +2,7 @@ import { LeuChipGroup } from './ChipGroup.js';
 import './_tslib-CNEFicEt.js';
 import 'lit/static-html.js';
 import 'lit/decorators.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 import 'lit';
 import './ChipSelectable.js';
 import './Chip.js';

package/dist/leu-chip-link.js

@@ -3,7 +3,7 @@ import './_tslib-CNEFicEt.js';
 import 'lit';
 import 'lit/decorators.js';
 import './Chip.js';
-import './LeuElement-BfbOWTGZ.js';
+import './LeuElement-BfXSO7MN.js';
 
 LeuChipLink.define("leu-chip-link");