@sandlada/mdc 0.1.0-nightly.14072025

package/build/components/progress-indicator/linear-progress-indicator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2025 Sandlada & Kai Orion
+ * SPDX-License-Identifier: MIT
+ */
+import { type TemplateResult } from 'lit';
+import { BaseProgressIndicator } from './base-progress-indicator';
+declare global {
+    interface HTMLElementTagNameMap {
+        "mdc-linear-progress-indicator": LinearProgressIndicator;
+    }
+}
+/**
+ * A progress component.
+ *
+ * @todo
+ * - wavy
+ *
+ * @version
+ * Material Design 3 - Expressive
+ *
+ * @link
+ * https://m3.material.io/components/progress-indicators/specs
+ */
+export declare class LinearProgressIndicator extends BaseProgressIndicator {
+    static styles: import("lit").CSSResult;
+    protected renderIndicator(): TemplateResult;
+}
+//# sourceMappingURL=linear-progress-indicator.d.ts.map

package/build/components/progress-indicator/linear-progress-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-progress-indicator.d.ts","sourceRoot":"","sources":["../../../src/components/progress-indicator/linear-progress-indicator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,KAAK,CAAA;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAGjE,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,qBAAqB;QAC3B,+BAA+B,EAAE,uBAAuB,CAAA;KAC3D;CACJ;AAED;;;;;;;;;;;GAWG;AACH,qBACa,uBAAwB,SAAQ,qBAAqB;IAE9D,OAAgB,MAAM,0BAA+B;cAElC,eAAe,IAAI,cAAc;CAkBvD"}

package/build/components/progress-indicator/linear-progress-indicator.js

@@ -0,0 +1 @@
+import{_ as s}from"../../tslib.es6-CmLYFWVC.js";import{x as i}from"../../lit-element-Bf8D1KRw.js";import{t}from"../../custom-element-Dz3n6kSt.js";import{BaseProgressIndicator as r}from"./base-progress-indicator.js";import{linearProgressIndicatorStyle as a}from"./progress-indicator.style.js";import"../../property-CHB_6zYv.js";import"../../class-map-DQX-4Y_I.js";import"../../utils/aria/delegate.js";import"../../utils/aria/aria.js";import"../../component-definitions/progress-indicator.definition.js";import"../../color-CigMJnjV.js";import"../../shape-CrZ0CLVJ.js";import"../../utils/tokens/create-logic-shape-tokens.js";import"../../utils/tokens/create-wrapped-tokens.js";import"../../utils/tokens/string-tokens.js";let e=class extends r{static{this.styles=a}renderIndicator(){return i`<span aria-hidden="true" class="stop-indicators"></span><div class="tracks" style="--_active-fraction:${this.value/this.max};--_inactive-fraction:${1-this.value/this.max}"><span aria-hidden="true" class="active-track"></span> <span aria-hidden="true" class="inactive-track"></span></div><div class="indeteminate-bar"><div class="bar primary-bar"><div class="bar-inner"></div></div><div class="bar secondary-bar"><div class="bar-inner"></div></div></div>`}};e=s([t("mdc-linear-progress-indicator")],e);export{e as LinearProgressIndicator};

package/build/components/progress-indicator/progress-indicator.style.d.ts

@@ -0,0 +1,2 @@
+export declare const linearProgressIndicatorStyle: import("lit").CSSResult;
+//# sourceMappingURL=progress-indicator.style.d.ts.map

package/build/components/progress-indicator/progress-indicator.style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-indicator.style.d.ts","sourceRoot":"","sources":["../../../src/components/progress-indicator/progress-indicator.style.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,4BAA4B,yBAyQxC,CAAA"}

package/build/components/progress-indicator/progress-indicator.style.js

@@ -0,0 +1,271 @@
+import{r as i,i as t}from"../../lit-element-Bf8D1KRw.js";import{LinearProgressIndicatorDefinition as a}from"../../component-definitions/progress-indicator.definition.js";import{createWrappedTokens as r}from"../../utils/tokens/create-wrapped-tokens.js";import{stringTokens as n}from"../../utils/tokens/string-tokens.js";import"../../color-CigMJnjV.js";import"../../shape-CrZ0CLVJ.js";import"../../utils/tokens/create-logic-shape-tokens.js";
+/**
+ * @license
+ * Copyright 2025 Sandlada & Kai Orion
+ * SPDX-License-Identifier: MIT
+ */const e=n(r("--mdc-linear-progress-indicator",a)),s=i("250ms"),o=i("cubic-bezier(0.4, 0, 0.6, 1)"),c=i("2s"),d=t`
+
+    @layer mdc.linear-progress-indicator.variable {
+        :host {
+            ${e};
+        }
+    }
+
+    @layer mdc.linear-progress-indicator.base {
+        :host {
+            border-start-start-radius: var(--_track-shape-start-start);
+            border-start-end-radius: var(--_track-shape-start-end);
+            border-end-start-radius: var(--_track-shape-end-start);
+            border-end-end-radius: var(--_track-shape-end-end);
+            display: flex;
+            position: relative;
+            min-width: 80px;
+            content-visibility: auto;
+            contain: strict;
+            margin-inline-start: 4px;
+            margin-inline-end: 4px;
+            height: var(--_height);
+        }
+
+        .progress {
+            position: absolute;
+            inset: 0;
+            direction: ltr;
+            border-radius: inherit;
+            overflow: hidden;
+            display: flex;
+            align-items: center;
+        }
+
+        .stop-indicators {
+            position: absolute;
+            inset: 0px;
+            z-index: 0;
+            &::before,
+            &::after {
+                content: "";
+                display: block;
+                z-index: 1;
+                position: absolute;
+                border-start-start-radius: var(--_stop-indicator-shape-start-start);
+                border-start-end-radius: var(--_stop-indicator-shape-start-end);
+                border-end-start-radius: var(--_stop-indicator-shape-end-start);
+                border-end-end-radius: var(--_stop-indicator-shape-end-end);
+                height: var(--_stop-indicator-size);
+                width: var(--_stop-indicator-size);
+                background: var(--_stop-indicator-color);
+            }
+            &::before {
+                inset: 0px;
+            }
+            &::after {
+                inset: calc(100% - var(--_stop-indicator-size));
+            }
+        }
+
+        .tracks {
+            --_inset-ltr: inset(
+                0
+                calc(var(--_inactive-fraction) * 100% + (var(--_stop-indicator-size) / 2))
+                0
+                0
+                round var(--_active-indicator-shape-start-start)
+            );
+            --_inset-rtl: inset(
+                0
+                0
+                0
+                calc(var(--_active-fraction) * 100% + (var(--_stop-indicator-size) / 2))
+                round var(--_active-indicator-shape-start-start)
+            );
+
+            .active-track,
+            .inactive-track {
+                position: absolute;
+                inset: 0px;
+                z-index: -1;
+            }
+
+            .active-track {
+                background: var(--_active-indicator-color);
+            }
+            .inactive-track {
+                background: var(--_track-color);
+            }
+
+
+            .active-track {
+                clip-path: var(--_inset-ltr);
+            }
+            .inactive-track {
+                clip-path: var(--_inset-rtl);
+            }
+        }
+
+        :not(.indeterminate) .indeteminate-bar {
+            visibility: hidden;
+        }
+        .indeterminate .indeteminate-bar {
+            visibility: visible;
+        }
+
+        .indeteminate-bar {
+            position: absolute;
+            inset: 0px;
+            .bar {
+                position: absolute;
+                animation: none;
+                width: 100%;
+                height: var(--_height);
+                transform-origin: left center;
+                transition: transform ${s} ${o};
+
+                .bar-inner {
+                    position: absolute;
+                    inset: 0;
+                    animation: none;
+                    background: var(--_active-indicator-color);
+                }
+            }
+            .primary-bar {
+                inset-inline-start: -145.167%;
+            }
+
+            .secondary-bar {
+                inset-inline-start: -54.8889%;
+                display: block;
+            }
+
+            .primary-bar {
+                animation: linear infinite ${c};
+                animation-name: primary-indeterminate-translate;
+            }
+
+            .primary-bar > .bar-inner {
+                animation: linear infinite ${c} primary-indeterminate-scale;
+            }
+
+            .secondary-bar {
+                animation: linear infinite ${c};
+                animation-name: secondary-indeterminate-translate;
+            }
+
+            .secondary-bar > .bar-inner {
+                animation: linear infinite ${c} secondary-indeterminate-scale;
+            }
+
+        }
+        :host(:dir(rtl)) {
+            transform: scale(-1);
+        }
+
+
+                @keyframes primary-indeterminate-scale {
+            0% {
+                transform: scaleX(0.08);
+            }
+
+            36.65% {
+                animation-timing-function: cubic-bezier(0.334731, 0.12482, 0.785844, 1);
+                transform: scaleX(0.08);
+            }
+
+            69.15% {
+                animation-timing-function: cubic-bezier(0.06, 0.11, 0.6, 1);
+                transform: scaleX(0.661479);
+            }
+
+            100% {
+                transform: scaleX(0.08);
+            }
+        }
+
+        @keyframes secondary-indeterminate-scale {
+            0% {
+                animation-timing-function: cubic-bezier(
+                0.205028,
+                0.057051,
+                0.57661,
+                0.453971
+                );
+                transform: scaleX(0.08);
+            }
+
+            19.15% {
+                animation-timing-function: cubic-bezier(
+                0.152313,
+                0.196432,
+                0.648374,
+                1.00432
+                );
+                transform: scaleX(0.457104);
+            }
+
+            44.15% {
+                animation-timing-function: cubic-bezier(
+                0.257759,
+                -0.003163,
+                0.211762,
+                1.38179
+                );
+                transform: scaleX(0.72796);
+            }
+
+            100% {
+                transform: scaleX(0.08);
+            }
+        }
+
+        @keyframes buffering {
+            0% {
+                transform: translateX(calc(var(--_stop-indicator-size) * 5));
+            }
+        }
+
+        @keyframes primary-indeterminate-translate {
+            0% {
+                transform: translateX(0px);
+            }
+
+            20% {
+                animation-timing-function: cubic-bezier(0.5, 0, 0.701732, 0.495819);
+                transform: translateX(0px);
+            }
+
+            59.15% {
+                animation-timing-function: cubic-bezier(
+                0.302435,
+                0.381352,
+                0.55,
+                0.956352
+                );
+                transform: translateX(83.6714%);
+            }
+
+            100% {
+                transform: translateX(200.611%);
+            }
+        }
+
+        @keyframes secondary-indeterminate-translate {
+            0% {
+                animation-timing-function: cubic-bezier(0.15, 0, 0.515058, 0.409685);
+                transform: translateX(0px);
+            }
+
+            25% {
+                animation-timing-function: cubic-bezier(0.31033, 0.284058, 0.8, 0.733712);
+                transform: translateX(37.6519%);
+            }
+
+            48.35% {
+                animation-timing-function: cubic-bezier(0.4, 0.627035, 0.6, 0.902026);
+                transform: translateX(84.3862%);
+            }
+
+            100% {
+                transform: translateX(160.278%);
+            }
+        }
+    }
+`;export{d as linearProgressIndicatorStyle};

package/build/components/radio-button/radio-button-selection-controller.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactiveController } from 'lit';
+/**
+ * An element that supports single-selection with `SingleSelectionController`.
+ */
+export interface SingleSelectionElement extends HTMLElement {
+    /**
+     * Whether or not the element is selected.
+     */
+    checked: boolean;
+}
+/**
+ * A `ReactiveController` that provides root node-scoped single selection for
+ * elements, similar to native `<input type="radio">` selection.
+ *
+ * To use, elements should add the controller and call
+ * `selectionController.handleCheckedChange()` in a getter/setter. This must
+ * be synchronous to match native behavior.
+ *
+ * @example
+ * const CHECKED = Symbol('checked');
+ *
+ * class MyToggle extends LitElement {
+ *   get checked() { return this[CHECKED]; }
+ *   set checked(checked: boolean) {
+ *     const oldValue = this.checked;
+ *     if (oldValue === checked) {
+ *       return;
+ *     }
+ *
+ *     this[CHECKED] = checked;
+ *     this.selectionController.handleCheckedChange();
+ *     this.requestUpdate('checked', oldValue);
+ *   }
+ *
+ *   [CHECKED] = false;
+ *
+ *   private selectionController = new SingleSelectionController(this);
+ *
+ *   constructor() {
+ *     super();
+ *     this.addController(this.selectionController);
+ *   }
+ * }
+ */
+export declare class SingleSelectionController implements ReactiveController {
+    /**
+     * All single selection elements in the host element's root with the same
+     * `name` attribute, including the host element.
+     */
+    get controls(): [SingleSelectionElement, ...SingleSelectionElement[]];
+    private focused;
+    private root;
+    private readonly host;
+    constructor(host: SingleSelectionElement);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Should be called whenever the host's `checked` property changes
+     * synchronously.
+     */
+    handleCheckedChange(): void;
+    private readonly handleFocusIn;
+    private readonly handleFocusOut;
+    private uncheckSiblings;
+    /**
+     * Updates the `tabindex` of the host and its siblings.
+     */
+    private updateTabIndices;
+    /**
+     * Handles arrow key events from the host. Using the arrow keys will
+     * select and check the next or previous sibling with the host's
+     * `name` attribute.
+     */
+    private readonly handleKeyDown;
+}
+//# sourceMappingURL=radio-button-selection-controller.d.ts.map

package/build/components/radio-button/radio-button-selection-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-button-selection-controller.d.ts","sourceRoot":"","sources":["../../../src/components/radio-button/radio-button-selection-controller.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,KAAK,CAAA;AAE7C;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACvD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB;IAChE;;;OAGG;IACH,IAAI,QAAQ,IAAI,CAAC,sBAAsB,EAAE,GAAG,sBAAsB,EAAE,CAAC,CAWpE;IAED,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwB;gBAEjC,IAAI,EAAE,sBAAsB;IAIxC,aAAa;IAeb,gBAAgB;IAShB;;;OAGG;IACH,mBAAmB;IASnB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAG5B;IAEF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAG7B;IAEF,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAqE5B;CACL"}

package/build/components/radio-button/radio-button-selection-controller.js

@@ -0,0 +1,6 @@
+import"../../lit-element-Bf8D1KRw.js";
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */class t{get controls(){const t=this.host.getAttribute("name");return t&&this.root&&this.host.isConnected?Array.from(this.root.querySelectorAll(`[name="${t}"]`)):[this.host]}constructor(t){this.focused=!1,this.root=null,this.handleFocusIn=()=>{this.focused=!0,this.updateTabIndices()},this.handleFocusOut=()=>{this.focused=!1,this.updateTabIndices()},this.handleKeyDown=t=>{const e="ArrowDown"===t.key,s="ArrowUp"===t.key,o="ArrowLeft"===t.key,n="ArrowRight"===t.key;if(!(o||n||e||s))return;const h=this.controls;if(!h.length)return;t.preventDefault();const i="rtl"===getComputedStyle(this.host).direction?o||e:n||e,c=h.indexOf(this.host);let d=i?c+1:c-1;for(;d!==c;){d>=h.length?d=0:d<0&&(d=h.length-1);const t=h[d];if(!t.hasAttribute("disabled")){for(const e of h)e!==t&&(e.checked=!1,e.tabIndex=-1,e.blur());t.checked=!0,t.tabIndex=0,t.focus(),t.dispatchEvent(new Event("change",{bubbles:!0}));break}i?d++:d--}},this.host=t}hostConnected(){this.root=this.host.getRootNode(),this.host.addEventListener("keydown",this.handleKeyDown),this.host.addEventListener("focusin",this.handleFocusIn),this.host.addEventListener("focusout",this.handleFocusOut),this.host.checked&&this.uncheckSiblings(),this.updateTabIndices()}hostDisconnected(){this.host.removeEventListener("keydown",this.handleKeyDown),this.host.removeEventListener("focusin",this.handleFocusIn),this.host.removeEventListener("focusout",this.handleFocusOut),this.updateTabIndices(),this.root=null}handleCheckedChange(){this.host.checked&&(this.uncheckSiblings(),this.updateTabIndices())}uncheckSiblings(){for(const t of this.controls)t!==this.host&&(t.checked=!1)}updateTabIndices(){const t=this.controls,e=t.find(t=>t.checked);if(e||this.focused){const s=e||this.host;s.tabIndex=0;for(const e of t)e!==s&&(e.tabIndex=-1);return}for(const e of t)e.tabIndex=0}}export{t as SingleSelectionController};

package/build/components/radio-button/radio-button.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2025 Kai-Orion & Sandlada
+ * SPDX-License-Identifier: MIT
+ */
+import { LitElement } from 'lit';
+import { createValidator, getValidityAnchor } from '../../utils/behaviors/constraint-validation';
+import { RadioValidator } from '../../utils/behaviors/validators/radio-validator';
+import { getFormState, getFormValue } from '../../utils/form/form-associated';
+declare global {
+    interface HTMLElementTagNameMap {
+        "mdc-radio-button": RadioButton;
+    }
+}
+declare const CHECKED: unique symbol;
+declare const RadioButton_base: import("../../utils/behaviors/mixin").MixinReturn<import("../../utils/behaviors/mixin").MixinReturn<import("../../utils/behaviors/mixin").MixinReturn<(abstract new (...args: any[]) => import("../../utils/behaviors/element-internals").WithElementInternals) & typeof LitElement & import("../../utils/form/form-associated").FormAssociatedConstructor, import("../../utils/form/form-associated").FormAssociated>, import("../../utils/behaviors/constraint-validation").ConstraintValidation>>;
+/**
+ *
+ * @version
+ * Material Design 3 - Expressive
+ *
+ * @link
+ * https://m3.material.io/components/radio-button/specs
+ */
+export declare class RadioButton extends RadioButton_base {
+    static styles: import("lit").CSSResult;
+    disabled: boolean;
+    name: string;
+    [CHECKED]: boolean;
+    private readonly maskId;
+    private readonly selectionController;
+    get checked(): boolean;
+    set checked(value: boolean);
+    required: boolean;
+    value: string;
+    private containerElement;
+    constructor();
+    protected render(): unknown;
+    protected updated(): void;
+    private handleClick;
+    private handleKeydown;
+    [getFormValue](): string | null;
+    [getFormState](): string;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string): void;
+    [createValidator](): RadioValidator;
+    [getValidityAnchor](): HTMLElement | null;
+}
+export {};
+//# sourceMappingURL=radio-button.d.ts.map

package/build/components/radio-button/radio-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-button.d.ts","sourceRoot":"","sources":["../../../src/components/radio-button/radio-button.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAkB,UAAU,EAAE,MAAM,KAAK,CAAA;AAIhD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAA6B,MAAM,6CAA6C,CAAA;AAE3H,OAAO,EAAE,cAAc,EAAE,MAAM,kDAAkD,CAAA;AAEjF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAuB,MAAM,kCAAkC,CAAA;AAKlG,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,qBAAqB;QAC3B,kBAAkB,EAAE,WAAW,CAAA;KAClC;CACJ;AAED,QAAA,MAAM,OAAO,eAAoB,CAAA;;AAEjC;;;;;;;GAOG;AACH,qBACa,WAAY,SAAQ,gBAAqG;IAElI,OAAgB,MAAM,0BAAmB;IAEjC,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IAEpB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAQ;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsC;IAE1E,IACW,OAAO,IAGQ,OAAO,CADhC;IACD,IAAW,OAAO,CAAC,KAAK,EAAE,OAAO,EAQhC;IAGM,QAAQ,EAAE,OAAO,CAAQ;IAGzB,KAAK,EAAE,MAAM,CAAO;IAG3B,OAAO,CAAC,gBAAgB,CAAqB;;cAY1B,MAAM,IAAI,OAAO;cAwBjB,OAAO;YAIZ,WAAW;YAiBX,aAAa;IASnB,CAAC,YAAY,CAAC;IAId,CAAC,YAAY,CAAC;IAIb,iBAAiB;IAMjB,wBAAwB,CAAC,KAAK,EAAE,MAAM;IAIvC,CAAC,eAAe,CAAC;IAYjB,CAAC,iBAAiB,CAAC;CAG9B"}

package/build/components/radio-button/radio-button.js

@@ -0,0 +1 @@
+import{_ as t}from"../../tslib.es6-CmLYFWVC.js";import{a as e,x as i}from"../../lit-element-Bf8D1KRw.js";import{t as s}from"../../custom-element-Dz3n6kSt.js";import{n as r}from"../../property-CHB_6zYv.js";import{e as o}from"../../query-DifSdHBD.js";import{e as n}from"../../class-map-DQX-4Y_I.js";import{mixinDelegatesAria as c}from"../../utils/aria/delegate.js";import{mixinConstraintValidation as l,createValidator as a,getValidityAnchor as d}from"../../utils/behaviors/constraint-validation.js";import{mixinElementInternals as h,internals as m}from"../../utils/behaviors/element-internals.js";import{RadioValidator as p}from"../../utils/behaviors/validators/radio-validator.js";import{isActivationClick as u}from"../../utils/event/form-label-activation.js";import{mixinFormAssociated as k,getFormValue as v,getFormState as f}from"../../utils/form/form-associated.js";import{generateUUID as b}from"../../utils/uuid/generate-uuid.js";import{SingleSelectionController as j}from"./radio-button-selection-controller.js";import{radioButtonStyle as y}from"./radio-button.style.js";import"../../utils/aria/aria.js";import"../../utils/behaviors/validators/validator.js";import"../../easing-5hHInU7b.js";import"../../component-definitions/radio-button.definition.js";import"../../color-CigMJnjV.js";import"../../state-C-haZXan.js";import"../../utils/tokens/create-wrapped-tokens.js";import"../../utils/tokens/override-component-tokens.js";import"../../utils/tokens/string-tokens.js";var g;const w=Symbol("checked");let C=class extends(c(l(k(h(e))))){static{this.styles=y}get checked(){return this[w]}set checked(t){if(t===this[w])return;const e=this[w];this[w]=t,this.requestUpdate("checked",e),this.selectionController.handleCheckedChange()}constructor(){super(),this[g]=!1,this.maskId=`maskid-${b()}`,this.selectionController=new j(this),this.required=!1,this.value="on",this.addController(this.selectionController),this[m].role="radio",this.addEventListener("click",this.handleClick.bind(this)),this.addEventListener("keydown",this.handleKeydown.bind(this))}render(){const t=n({selected:this.checked,unselected:!this.checked});return i`<div class="container ${t}" aria-hidden="true"><mdc-ripple .control="${this}" .disabled="${this.disabled}" part="ripple"></mdc-ripple><mdc-focus-ring .control="${this}" part="focus-ring"></mdc-focus-ring><svg class="icon" viewBox="0 0 20 20"><mask id="${this.maskId}"><rect width="100%" height="100%" fill="white"/><circle cx="10" cy="10" r="8" fill="black"/></mask><circle class="outer circle" cx="10" cy="10" r="10" mask="url(#${this.maskId})"/><circle class="inner circle" cx="10" cy="10" r="5"/></svg><div class="touch-target"></div></div>`}updated(){this[m].ariaChecked=String(this.checked)}async handleClick(t){this.disabled||(await 0,t.defaultPrevented||(u(t)&&this.focus(),this.checked=!0,this.dispatchEvent(new Event("change",{bubbles:!0})),this.dispatchEvent(new InputEvent("input",{bubbles:!0,composed:!0}))))}async handleKeydown(t){await 0," "!==t.key||t.defaultPrevented||this.click()}[(g=w,v)](){return this.checked?this.value:null}[f](){return String(this.checked)}formResetCallback(){this.checked=this.hasAttribute("checked")}formStateRestoreCallback(t){this.checked="true"===t}[a](){return new p(()=>this.selectionController?this.selectionController.controls:[this])}[d](){return this.containerElement}};t([r({type:Boolean})],C.prototype,"checked",null),t([r({type:Boolean})],C.prototype,"required",void 0),t([r({type:String})],C.prototype,"value",void 0),t([o(".container")],C.prototype,"containerElement",void 0),C=t([s("mdc-radio-button")],C);export{C as RadioButton};

package/build/components/radio-button/radio-button.style.d.ts

@@ -0,0 +1,2 @@
+export declare const radioButtonStyle: import("lit").CSSResult;
+//# sourceMappingURL=radio-button.style.d.ts.map

package/build/components/radio-button/radio-button.style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-button.style.d.ts","sourceRoot":"","sources":["../../../src/components/radio-button/radio-button.style.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB,yBAmJ5B,CAAA"}

package/build/components/radio-button/radio-button.style.js

@@ -0,0 +1,143 @@
+import{E as e}from"../../easing-5hHInU7b.js";import{r as o,i as t}from"../../lit-element-Bf8D1KRw.js";import{RadioButtonDefinition as i}from"../../component-definitions/radio-button.definition.js";import{createWrappedTokens as r}from"../../utils/tokens/create-wrapped-tokens.js";import{overrideComponentTokens as s}from"../../utils/tokens/override-component-tokens.js";import{stringTokens as c}from"../../utils/tokens/string-tokens.js";import"../../color-CigMJnjV.js";import"../../state-C-haZXan.js";
+/**
+ * @license
+ * Copyright 2025 Kai-Orion & Sandlada
+ * SPDX-License-Identifier: MIT
+ */const a=c(r("--mdc-radio-button",i)),l=o(e.ExpressiveFastSpatial),n=t`
+    @layer mdc.radio-button {
+        @layer variable {
+            :host { ${a} }
+        }
+
+        @layer base {
+            :host {
+                display: inline-flex;
+                outline: none;
+                position: relative;
+                vertical-align: top;
+                -webkit-tap-highlight-color: transparent;
+                cursor: pointer;
+                height: var(--_icon-size);
+                width: var(--_icon-size);
+                margin: max(0px, ((48px - var(--_state-layer-size)) / 1));
+            }
+
+            :host([disabled]) {
+                cursor: default;
+                pointer-events: none;
+            }
+
+            :host([touch-target='none']) {
+                margin: 0px;
+            }
+
+            .container {
+                display: flex;
+                height: 100%;
+                place-content: center;
+                place-items: center;
+                width: 100%;
+            }
+
+            .touch-target {
+                height: 48px;
+                position: absolute;
+                width: 48px;
+            }
+
+            .icon {
+                fill: var(--_unselected-icon-color);
+                inset: 0;
+                position: absolute;
+            }
+            .selected .icon {
+                fill: var(--_selected-icon-color);
+            }
+
+            .outer.circle {
+                transition: fill 50ms linear;
+            }
+            .inner.circle {
+                scale: 0;
+                opacity: 0;
+                transform-origin: center;
+                transition: scale 350ms ${l}, opacity 350ms ${l};
+            }
+            .selected .inner.circle {
+                scale: 1;
+                opacity: 1;
+            }
+
+            :host([disabled]) .circle {
+                animation-duration: 0s;
+                transition-duration: 0s;
+            }
+
+            :host(:hover) .icon {
+                fill: var(--_hovered-unselected-icon-color);
+            }
+            :host(:focus-within) .icon {
+                fill: var(--_focused-unselected-icon-color);
+            }
+            :host(:active) .icon {
+                fill: var(--_pressed-unselected-icon-color);
+            }
+
+            :host([disabled]) .icon {
+                fill: var(--_disabled-unselected-icon-color);
+                opacity: var(--_disabled-unselected-icon-opacity);
+            }
+
+            :host(:hover) .selected .icon {
+                fill: var(--_hovered-selected-hover-icon-color);
+            }
+            :host(:focus-within) .selected .icon {
+                fill: var(--_focused-selected-focus-icon-color);
+            }
+            :host(:active) .selected .icon {
+                fill: var(--_pressed-selected-pressed-icon-color);
+            }
+            :host([disabled]) .selected .icon {
+                fill: var(--_disabled-selected-icon-color);
+                opacity: var(--_disabled-selected-icon-opacity);
+            }
+        }
+
+        @layer hcm {
+            @media (forced-colors: active) {
+                .icon {
+                    fill: CanvasText;
+                }
+
+                :host([disabled]) .icon {
+                    fill: GrayText;
+                    opacity: 1;
+                }
+            }
+        }
+
+        @layer composite.ripple {
+            .container mdc-ripple {
+                border-radius: 50%;
+                inset: unset;
+                height: var(--_state-layer-size);
+                width: var(--_state-layer-size);
+            }
+            .container.selected mdc-ripple {
+                ${o(c(s("--mdc-ripple",{"hovered-color":"var(--_hovered-selected-state-layer-color)","hovered-opacity":"var(--_hovered-selected-state-layer-opacity)","pressed-color":"var(--_pressed-selected-state-layer-color)","pressed-opacity":"var(--_pressed-selected-state-layer-opacity)"})))}
+            }
+            .container:not(.selected) mdc-ripple {
+                ${o(c(s("--mdc-ripple",{"hovered-color":"var(--_hovered-unselected-state-layer-color)","hovered-opacity":"var(--_hovered-unselected-state-layer-opacity)","pressed-color":"var(--_pressed-unselected-state-layer-color)","pressed-opacity":"var(--_pressed-unselected-state-layer-opacity)"})))}
+            }
+        }
+
+        @layer composite.focus-ring {
+            .container mdc-focus-ring {
+                height: calc(var(--_icon-size) + 3px);
+                width: calc(var(--_icon-size) + 3px);
+                inset: unset;
+                border-radius: 50%;
+            }
+        }
+    }
+`;export{n as radioButtonStyle};