@rak200/ui 0.3.0 → 0.5.0

package/dist/radio.js

@@ -1,5 +1,19 @@
-import { LitElement, css, html } from 'lit';
+import { LitElement, css, html, nothing } from 'lit';
 import { reference } from './reference.js';
+// Stryker disable next-line StringLiteral: both ends of this event read the constant — the
+// declaration dispatches it and the group listens for it — so a different name, the empty
+// string included, still meets itself. Nothing outside this module names it, which is what
+// makes the mutant provably equivalent rather than merely uncaught.
+const announcement = 'ui-radio-changed';
+/**
+ * The name the rendered controls share, which is what makes them one group.
+ *
+ * It never leaves this shadow root and never reaches a form: a radio group with no form
+ * owner is scoped by its **tree**, so one literal is safe in every instance on a page —
+ * two groups carrying it are two groups, measured. What a form submits is the host's own
+ * `name`, through `ElementInternals`.
+ */
+const grouping = 'option';
 /**
  * The size the control is drawn at, and a floor rather than a preference.
  *
@@ -31,60 +45,206 @@ const whole = css `linear-gradient(#000, #000)`;
  */
 const mark = css `radial-gradient(circle closest-side, #000 100%, transparent 100%)`;
 /**
- * One option's control, drawn from the token layer rather than replaced.
+ * One choice in a {@link UiRadioGroup}: a value, and the text beside it.
  *
- * **The `<input type="radio">` is yours.** You write it, you set its `name`, `value`,
- * `checked` and `disabled`, and it stays in the light DOM — the shape every control in
- * this kit has, and forced by the same constraint: an ARIA relationship by IDREF does not
- * cross a shadow boundary, so a control rendered in here could not be labelled by the
- * `<label>` around it.
- *
- * **This element carries no state and no name.** It is a drawing, and everything that
- * makes a set of radios *a group* — one tab stop, arrow keys that move and select, one
- * value out of the set — is the platform's, because they are native radios sharing a
- * `name`. Wrapping each one changes none of that: measured in this suite, a group whose
- * radios sit inside custom elements is still one group.
+ * **It draws nothing.** The group renders the real `<input type="radio">` and the
+ * `<label>` around it, because a `role="radiogroup"`, the name pointing at it and the
+ * controls it contains have to share one tree scope — `ARCHITECTURE.md`, *A relationship
+ * needs one tree scope*. So this element exists to be read rather than to be seen, the way
+ * `<ui-option>` does for `<ui-select>`.
  *
  * @example
  * ```html
- * <label>
- *   <ui-radio><input type="radio" name="plan" value="free" /></ui-radio>
- *   Free
- * </label>
+ * <ui-radio value="free">Free</ui-radio>
  * ```
  */
 export class UiRadio extends LitElement {
+    constructor() {
+        super(...arguments);
+        /** What the group submits while this choice is the one in force. */
+        this.value = '';
+        /** Whether this is the choice a group with no `value` starts on, and resets to. */
+        this.checked = false;
+        /** Whether this one choice refuses interaction, the rest of the set staying live. */
+        this.disabled = false;
+        this.#announce = () => {
+            this.dispatchEvent(new Event(announcement, { bubbles: true }));
+        };
+    }
+    static { this.styles = css `
+        :host {
+            display: none;
+        }
+    `; }
+    static { this.properties = {
+        value: { type: String, reflect: true },
+        checked: { type: Boolean, reflect: true },
+        disabled: { type: Boolean, reflect: true },
+    }; }
+    /**
+     * Tells the group something changed, on every update and on every slot change.
+     *
+     * A property write is not something a `MutationObserver` reports, which is what makes a
+     * declaration this package owns different from an element a host wrote: the property is
+     * reactive here. It bubbles because the choices are the group's own light-DOM children,
+     * and it is dispatched from `updated()` rather than from `disconnectedCallback`, which
+     * has no path left to bubble along.
+     */
+    updated() {
+        this.#announce();
+    }
+    #announce;
+    render() {
+        return html `<slot @slotchange=${this.#announce}></slot>`;
+    }
+}
+/**
+ * A set of choices, laid out and named as one thing.
+ *
+ * **It hand-rolls no roving tabindex and it brings no state machine.** Native radios
+ * sharing a `name` **are** the APG **Radio Group** pattern — one tab stop, arrow keys that
+ * move *and* select, wrapping at the ends, and left/right swapped under `dir="rtl"` — and
+ * that holds inside a shadow root, where the group is scoped by its tree because the
+ * controls have no form owner. `tests/radio.test.ts` measures it rather than trusting it.
+ * `ARCHITECTURE.md`, *Behaviour is delegated*, carries why no machine arrived.
+ *
+ * **What it owns is what the platform leaves out**: the drawing, the layout, the group's
+ * own name, help and message, and form participation through `ElementInternals` — a
+ * control in a shadow root has no form owner, so the element answers for the value, the
+ * validity and the three form lifecycle callbacks.
+ *
+ * @example
+ * ```html
+ * <ui-radio-group label="Plan" name="plan" help="Change it any time.">
+ *   <ui-radio value="free">Free</ui-radio>
+ *   <ui-radio value="pro" checked>Pro</ui-radio>
+ * </ui-radio-group>
+ * ```
+ */
+export class UiRadioGroup extends LitElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * The accessible name, and the text above the set.
+         *
+         * A plain field rather than the `accessor` keyword, for the reason `src/button.ts`
+         * gives beside its own — and so for every property below.
+         */
+        this.label = '';
+        /** Supporting text under the set, which survives an error rather than yielding. */
+        this.help = '';
+        /** The message, which paints the boundaries and is announced with the group. */
+        this.error = '';
+        /**
+         * The name the value is submitted under.
+         *
+         * **Reflected, and that is a requirement rather than a convenience.** A form names a
+         * form-associated custom element's entry from the content attribute, so a host who set
+         * only the property would submit nothing at all — silently.
+         */
+        this.name = '';
+        /**
+         * The choice currently made.
+         *
+         * **Empty means _the declared default_ rather than _nothing_**, which is what lets a
+         * `<ui-radio checked>` mean what `<input checked>` means and a reset return to it.
+         * Not reflected, the way a native control's `checked` IDL attribute is not.
+         */
+        this.value = '';
+        /** Which way the options are laid out, and what the group announces it did. */
+        this.orientation = 'vertical';
+        /** Whether a form is invalid while no choice is made. */
+        this.required = false;
+        /** Whether the whole set refuses interaction, and submits nothing. */
+        this.disabled = false;
+        this.#internals = this.attachInternals();
+        this.#redraw = () => {
+            this.requestUpdate();
+        };
+        /** A choice made by hand, mirrored back and re-dispatched. */
+        this.#changed = (event) => {
+            this.value = event.target.value;
+            this.dispatchEvent(new Event('change', { bubbles: true }));
+        };
+    }
     static { this.styles = css `
         :host {
-            display: inline-flex;
+            display: block;
+            font-family: ${reference('--ui-font')};
+        }
+
+        /* The rhythm ui-field used to own, now owned by the control it was wrapping. */
+        .stack {
+            display: flex;
+            flex-direction: column;
+            gap: calc(${reference('--ui-space')} / 2);
         }
 
-        /* Everything below reaches a control the *host* wrote, through ::slotted — the
-           whole shape of this component, and the same one ui-checkbox has.
+        .label {
+            color: ${reference('--ui-color-text')};
+        }
 
-           appearance: none is its whole cost, and it is taken for the reason
+        :host([disabled]) .label {
+            color: ${reference('--ui-color-text-muted')};
+        }
+
+        .options {
+            display: flex;
+            flex-direction: column;
+            gap: calc(${reference('--ui-space')} / 2);
+        }
+
+        /* Laid out by the attribute rather than by the host's own CSS, so the drawing and
+           the announcement cannot disagree: orientation sets both this rule and
+           aria-orientation, and a host who reached for flex-direction instead would change
+           one of the two. */
+        :host([orientation='horizontal']) .options {
+            flex-direction: row;
+            flex-wrap: wrap;
+            column-gap: calc(${reference('--ui-space')} * 2);
+        }
+
+        /* The label CONTAINS its control, so there is no IDREF to resolve and no id to
+           generate — the same shape src/checkbox.ts takes, and the reason the click target
+           covers the text for free. align-items rather than center: an option whose text
+           wraps to two lines should keep its control on the first. */
+        .option {
+            display: flex;
+            align-items: center;
+            gap: calc(${reference('--ui-space')} / 2);
+            color: ${reference('--ui-color-text')};
+            cursor: pointer;
+        }
+
+        .option:has(input:disabled) {
+            color: ${reference('--ui-color-text-muted')};
+            cursor: not-allowed;
+        }
+
+        /* appearance: none is this component's whole cost, and it is taken for the reason
            ARCHITECTURE.md states as a debt rather than a free hand: it removes the
            platform's dot, its target size and its behaviour under forced colors in one
            declaration, and each of those is answered below. What it buys is a radio that
            belongs beside the checkbox this kit already draws — a native 13px radio next to
            a drawn 24px checkbox would argue cosmetically for a difference that is
            semantic. */
-        ::slotted(input) {
+        input {
             appearance: none;
             box-sizing: border-box;
-            /* The user agent puts 3px around a radio. Left in, it would sit inside the
-               host box and put the control off centre in any layout that aligns to it. */
+            flex: none;
+            /* The user agent puts 3px around a radio. Left in, it would put the control
+               off centre against the text beside it. */
             margin: 0;
             inline-size: ${size};
             block-size: ${size};
-            /* A circle, and the one measurement here that is not a token: the shape is
-               what tells a radio from a checkbox before either is read, so it cannot
-               follow --ui-radius without a square radio becoming possible. */
+            /* A circle, and the one measurement here that is not a token: the shape is what
+               tells a radio from a checkbox before either is read, so it cannot follow
+               --ui-radius without a square radio becoming possible. */
             border-radius: 50%;
             background-color: ${reference('--ui-color-surface')};
             background-repeat: no-repeat;
             border: 1px solid ${reference('--ui-color-border')};
-            cursor: pointer;
+            cursor: inherit;
             /* The focus ring is deliberately not in this list, for the reason
                src/button.ts gives beside its own: delaying the affordance that says *this
                is where you are* is the opposite of what it exists to do. */
@@ -94,10 +254,10 @@ export class UiRadio extends LitElement {
                 border-color ${reference('--ui-duration-state')} ${reference('--ui-easing-state')};
         }
 
-        /* The mark is a hole: the whole control, minus the circle, so what shows through
-           is whatever the control sits on. The docblock on the mask constant says why a
-           hole rather than a colour. */
-        ::slotted(input:checked) {
+        /* The mark is a hole: the whole control, minus the circle, so what shows through is
+           whatever the control sits on. The docblock on the mask constant says why a hole
+           rather than a colour. */
+        input:checked {
             background-color: ${reference('--ui-color-accent')};
             border-color: ${reference('--ui-color-accent')};
             mask-image: ${whole}, ${mark};
@@ -116,32 +276,52 @@ export class UiRadio extends LitElement {
 
            The disabled guard is measured rather than assumed: a disabled control still
            matches :hover. */
-        ::slotted(input:hover:not(:disabled)) {
+        input:hover:not(:disabled) {
             border-color: ${reference('--ui-color-text')};
         }
 
-        ::slotted(input:checked:hover:not(:disabled)) {
+        input:checked:hover:not(:disabled) {
             background-color: ${reference('--ui-color-accent-hover')};
             border-color: ${reference('--ui-color-accent-hover')};
         }
 
-        /* A visible focus ring is not decoration: removing it is the single most common
-           way a component stops being usable by keyboard — and on a radio group it is the
-           only thing that says which option an arrow key just moved to. */
-        ::slotted(input:focus-visible) {
+        /* A visible focus ring is not decoration: removing it is the single most common way
+           a component stops being usable by keyboard — and on a radio group it is the only
+           thing that says which option an arrow key just moved to. */
+        input:focus-visible {
             outline: 2px solid ${reference('--ui-color-focus')};
             outline-offset: 2px;
         }
 
-        ::slotted(input:disabled) {
+        input:disabled {
             cursor: not-allowed;
             opacity: 0.5;
         }
 
-        /* There is no error rule here, and its absence is the decision: what a radio group
-           gets wrong is the *choice*, not one option, so ui-radio-group paints the state
-           for the whole set. It does it by retargeting the boundary token over its own
-           subtree, which this rule reads without knowing anything about it. */
+        /* The error is the SET's, not one option's: what a radio group gets wrong is the
+           choice. Read off the rendered aria-invalid rather than a reflected attribute on
+           the host, which is the trap ui-checkbox measured — Lit reflects an empty string
+           default as an empty attribute, and an attribute-presence selector matches every
+           element.
+
+           This used to retarget --ui-color-border over the whole subtree, because no
+           selector in this sheet could reach a control two elements down in the host's
+           tree. The controls are in here now, so the rule names them. */
+        .options[aria-invalid='true'] input {
+            border-color: ${reference('--ui-color-danger')};
+        }
+
+        .help {
+            color: ${reference('--ui-color-text')};
+            font-size: ${reference('--ui-text-supporting')};
+        }
+
+        /* Colour is not the only cue — the message says what is wrong, and aria-invalid
+           marks the group whatever the styling does. */
+        .error {
+            color: ${reference('--ui-color-danger')};
+            font-size: ${reference('--ui-text-supporting')};
+        }
 
         /* Forced colors replaces every author colour with one from the user's palette, so
            the accent that says *selected* becomes the same Canvas as the surface that says
@@ -150,135 +330,186 @@ export class UiRadio extends LitElement {
            selected state names Highlight and the difference survives; the mark keeps
            working untouched, because a mask has no colour to force.
 
-           Opacity is not a colour and is not forced, so the disabled control would still
-           be half-transparent against a palette chosen for contrast. GrayText is what that
+           Opacity is not a colour and is not forced, so the disabled control would still be
+           half-transparent against a palette chosen for contrast. GrayText is what that
            mode has for *unavailable*, and it is a colour rather than a veil. */
         @media (forced-colors: active) {
-            ::slotted(input:checked) {
+            input:checked {
                 background-color: Highlight;
                 border-color: Highlight;
             }
 
-            ::slotted(input:disabled) {
+            input:disabled {
                 border-color: GrayText;
                 opacity: 1;
             }
         }
     `; }
-    render() {
-        return html `<slot></slot>`;
-    }
-}
-/**
- * A set of radios, laid out and named as one thing.
- *
- * **It hand-rolls no roving tabindex and it brings no state machine**, and that is this
- * element's whole claim rather than a gap in it. Issue #15 asked which of the two it would
- * be, because the APG **Radio Group** pattern — one tab stop, arrow keys that move *and*
- * select, wrapping at the ends — is the first behaviour in the v0 cut that could have
- * justified Zag. Neither was needed: native radios sharing a `name` **are** that pattern,
- * and this suite measures it here rather than trusting it, wrappers and all.
- *
- * That is the test `ROADMAP.md` states, applied: Zag arrives where the platform has **no
- * element** for the pattern, not merely where the pattern has state. `ui-menu` is where
- * that question is open; a radio group is not.
- *
- * **What is left for this element is what the platform leaves out**: the layout, the
- * `role` that makes a set of radios a group to a screen reader, and the group-level name,
- * description and error state — which {@link UiField} wires onto *this* element rather
- * than onto an option, because a `<label for>` naming one radio names one option and
- * leaves the group anonymous.
- *
- * @example
- * ```html
- * <ui-field>
- *   <label slot="label">Plan</label>
- *   <ui-radio-group>
- *     <label><ui-radio><input type="radio" name="plan" value="free" /></ui-radio> Free</label>
- *     <label><ui-radio><input type="radio" name="plan" value="pro" /></ui-radio> Pro</label>
- *   </ui-radio-group>
- * </ui-field>
- * ```
- */
-export class UiRadioGroup extends LitElement {
-    constructor() {
-        super(...arguments);
-        /**
-         * Which way the options are laid out.
-         *
-         * A plain field rather than the `accessor` keyword, for the reason `src/button.ts`
-         * gives beside its own: the browser this suite runs in does not implement
-         * auto-accessors, and the module would fail to parse.
-         */
-        this.orientation = 'vertical';
-    }
-    static { this.styles = css `
-        :host {
-            display: flex;
-            flex-direction: column;
-            gap: calc(${reference('--ui-space')} / 2);
-        }
-
-        /* Laid out by the attribute rather than by the host's own CSS, so the drawing and
-           the announcement cannot disagree: orientation sets both this rule and
-           aria-orientation, and a host who reached for flex-direction instead would
-           change one of the two. */
-        :host([orientation='horizontal']) {
-            flex-direction: row;
-            flex-wrap: wrap;
-            column-gap: calc(${reference('--ui-space')} * 2);
-        }
-
-        /* The error, painted for the whole set by retargeting the boundary token over this
-           subtree — which is the override surface the token layer already publishes,
-           pointed at the group's own descendants instead of at a page.
-
-           A custom property inherits through a shadow boundary and a selector does not, so
-           this is what reaches a control two elements down that this sheet cannot name:
-           ::slotted() stops at the group's own children, :host-context() is not
-           cross-engine, and :host(:has(...)) is invalid in this engine. The value still
-           arrives as a token reference, so a host who retunes danger retunes this too.
-
-           aria-invalid is not written here: ui-field sets it as part of the wiring it
-           already owns, so the message under the group and the boundary around its options
-           cannot disagree about whether there is an error. */
-        :host([aria-invalid='true']) {
-            --ui-color-border: ${reference('--ui-color-danger')};
-        }
-    `; }
+    static { this.formAssociated = true; }
+    /**
+     * Focus is delegated, so `focus()` and `reportValidity()` reach a control — the host is
+     * not a focusable element. Measured with the group: the delegation lands on the first
+     * option rather than making all of them tab stops, because the roving one is still the
+     * platform's.
+     */
+    static { this.shadowRootOptions = {
+        ...LitElement.shadowRootOptions,
+        delegatesFocus: true,
+    }; }
     static { this.properties = {
+        label: { type: String, reflect: true },
+        help: { type: String, reflect: true },
+        error: { type: String, reflect: true },
+        name: { type: String, reflect: true },
+        // Stryker disable next-line ObjectLiteral: `{}` is what Lit's default converter
+        // already does for a string — `type` only switches the converter for Boolean,
+        // Number, Object and Array — and `reflect` defaults to false either way. The
+        // declaration is written out to say which of the two `value` is, not to change it.
+        value: { type: String },
         orientation: { type: String, reflect: true },
+        required: { type: Boolean, reflect: true },
+        disabled: { type: Boolean, reflect: true },
     }; }
+    #internals;
+    #redraw;
+    connectedCallback() {
+        super.connectedCallback();
+        // The half a slot cannot report: a property write on a choice. It reaches here by
+        // bubbling, because the choices are this element's own light-DOM children.
+        //
+        // There is deliberately no removal in `disconnectedCallback`. A listener an element
+        // holds on *itself* cannot outlive it, and `#redraw` is one stable reference, so
+        // re-adding it on a reconnect is discarded rather than doubled.
+        this.addEventListener(announcement, this.#redraw);
+    }
+    /** Every choice a host declared, in the order they were written. */
+    #choices() {
+        return [...this.querySelectorAll('ui-radio')];
+    }
     /**
-     * Marks the element a group before anything asks what it is.
+     * The choice in force: the host's `value` where it names one, the declared default
+     * otherwise.
      *
-     * In `connectedCallback` rather than at first render, and the timing is the point:
-     * {@link UiField} reads this attribute to decide that the group — and not the first
-     * radio inside it — is the thing to name, and it does so on its own first update,
-     * which lands before this element's. Set a microtask later, the role would arrive
-     * after the only reader that needs it.
+     * The fallback is the platform's own rule read off the declarations — the first choice
+     * marked `checked`, and failing that nothing at all, which is what a native set with no
+     * checked radio in it does. A radio group differs from a `<select>` exactly here: it
+     * has an empty state and a drop-down does not.
+     */
+    #chosen() {
+        const choices = this.#choices();
+        if (choices.some((choice) => choice.value === this.value)) {
+            return this.value;
+        }
+        return choices.find((choice) => choice.checked)?.value ?? '';
+    }
+    /** The validity, taken from a control that computed it. */
+    #publish(control) {
+        if (this.error !== '') {
+            this.#internals.setValidity({ customError: true }, this.error, control);
+            return;
+        }
+        this.#internals.setValidity(control.validity, control.validationMessage, control);
+    }
+    /**
+     * The value and the validity, which move together here or disagree anywhere.
      *
-     * A `role` the host wrote is never overwritten, the same courtesy {@link UiField}
-     * extends to an `id` it finds already there.
+     * The first control is the one asked, and it is the one the browser would focus when a
+     * form reports an invalid group. Iterated rather than asserted, for the reason
+     * `src/input.ts` gives beside the same shape: a null branch here is unreachable, which
+     * is a coverage hole and an immortal mutant at once.
      */
-    connectedCallback() {
-        super.connectedCallback();
-        if (!this.hasAttribute('role')) {
-            this.setAttribute('role', 'radiogroup');
+    updated() {
+        this.#internals.setFormValue(this.#chosen());
+        for (const control of this.renderRoot.querySelectorAll('input')) {
+            this.#publish(control);
+            return;
         }
+        // A group with no choices declared has nothing to validate against and nothing to
+        // submit, which is a state a host can reach by writing an empty element.
+        this.#internals.setValidity({});
+    }
+    /** A choice made by hand, mirrored back and re-dispatched. */
+    #changed;
+    /** A form reset, which returns to the choice the declarations name. */
+    formResetCallback() {
+        this.value = '';
+    }
+    /** A `<fieldset disabled>` above this element, which reaches it and nothing below. */
+    formDisabledCallback(disabled) {
+        this.disabled = disabled;
+    }
+    /** Restoring after a back-navigation, where the browser hands the value back. */
+    formStateRestoreCallback(state) {
+        this.value = state ?? '';
+    }
+    /** The form this element participates in, for a host that needs it. */
+    get form() {
+        return this.#internals.form;
+    }
+    /** Whether the group currently satisfies its constraints. */
+    get validity() {
+        return this.#internals.validity;
+    }
+    /** The message a form would report for it, empty while the group is valid. */
+    get validationMessage() {
+        return this.#internals.validationMessage;
+    }
+    /** The ids describing the group, in the order a reader needs them. */
+    #described() {
+        const ids = [this.error === '' ? '' : 'error', this.help === '' ? '' : 'help'].filter((id) => id !== '');
+        return ids.length === 0 ? nothing : ids.join(' ');
     }
     /**
-     * Keeps the announced orientation on the drawn one.
+     * One declaration, as the label and control the platform needs.
      *
-     * Written unconditionally rather than only for the horizontal case: the default a
-     * screen reader assumes for a `radiogroup` is not something a component should have an
-     * opinion about, and the attribute costs nothing to state.
+     * **`.checked` is a property binding and `?checked` would be wrong**, which is not a
+     * style choice: on a radio the content attribute is `defaultChecked`, so once the
+     * control has been interacted with — or once anything has set the property — the
+     * attribute stops driving the live state. Measured, as a reset that redrew the
+     * declared default and left the control on the choice the reader had made.
      */
-    willUpdate() {
-        this.setAttribute('aria-orientation', this.orientation);
+    #draw(choice, chosen) {
+        return html `<label class="option" part="option">
+            <input
+                type="radio"
+                part="control"
+                name=${grouping}
+                value=${choice.value}
+                .checked=${choice.value === chosen}
+                ?disabled=${this.disabled || choice.disabled}
+                ?required=${this.required}
+                @change=${this.#changed}
+            />
+            <span part="option-label">${choice.textContent}</span>
+        </label>`;
     }
     render() {
-        return html `<slot></slot>`;
+        const chosen = this.#chosen();
+        return html `
+            <div class="stack" part="stack">
+                <span class="label" id="label" part="label">${this.label}</span>
+                <div
+                    class="options"
+                    part="options"
+                    role="radiogroup"
+                    aria-labelledby="label"
+                    aria-orientation=${this.orientation}
+                    aria-invalid=${this.error === '' ? nothing : 'true'}
+                    aria-describedby=${this.#described()}
+                >
+                    ${this.#choices().map((choice) => this.#draw(choice, chosen))}
+                </div>
+                ${this.help === ''
+            ? nothing
+            : html `<span class="help" id="help" part="help">${this.help}</span>`}
+                ${this.error === ''
+            ? nothing
+            : html `<span class="error" id="error" part="error">${this.error}</span>`}
+                <!-- The structural half, which slotchange reports and no observer has to.
+                     What it holds draws nothing: a declaration is display: none. -->
+                <slot @slotchange=${this.#redraw}></slot>
+            </div>
+        `;
     }
 }
 // Stryker disable next-line StringLiteral: the registration runs once, at import, inside

package/dist/radio.js.map

@@ -1 +1 @@
-{"version":3,"file":"radio.js","sourceRoot":"","sources":["../src/radio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAuB,MAAM,KAAK,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAK3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,IAAI,GAAG,GAAG,CAAA,kBAAkB,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC;AAElE,uFAAuF;AACvF,MAAM,KAAK,GAAG,GAAG,CAAA,6BAA6B,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,IAAI,GAAG,GAAG,CAAA,mEAAmE,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,OAAQ,SAAQ,UAAU;aACV,WAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;2BAqBd,IAAI;0BACL,IAAI;;;;;gCAKE,SAAS,CAAC,oBAAoB,CAAC;;gCAE/B,SAAS,CAAC,mBAAmB,CAAC;;;;;;mCAM3B,SAAS,CAAC,qBAAqB,CAAC;sBAC7C,SAAS,CAAC,mBAAmB,CAAC;+BACrB,SAAS,CAAC,qBAAqB,CAAC,IAAI,SAAS,CAAC,mBAAmB,CAAC;;;;;;;gCAOjE,SAAS,CAAC,mBAAmB,CAAC;4BAClC,SAAS,CAAC,mBAAmB,CAAC;0BAChC,KAAK,KAAK,IAAI;;;;uBAIjB,IAAI;;;;;;;;;;;;;4BAaC,SAAS,CAAC,iBAAiB,CAAC;;;;gCAIxB,SAAS,CAAC,yBAAyB,CAAC;4BACxC,SAAS,CAAC,yBAAyB,CAAC;;;;;;;iCAO/B,SAAS,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmCzD,CAAC;IAEO,MAAM;QACX,OAAO,IAAI,CAAA,eAAe,CAAC;IAC/B,CAAC;;AAGL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IAA5C;;QAwCI;;;;;;WAMG;QACH,gBAAW,GAAqB,UAAU,CAAC;IAoC/C,CAAC;aAlF4B,WAAM,GAAG,GAAG,CAAA;;;;wBAIjB,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;+BAUhB,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;iCAiBrB,SAAS,CAAC,mBAAmB,CAAC;;KAE1D,AAjC8B,CAiC7B;aAEuB,eAAU,GAAG;QAClC,WAAW,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;KAC/C,AAFkC,CAEjC;IAWF;;;;;;;;;;;OAWG;IACM,iBAAiB;QACtB,KAAK,CAAC,iBAAiB,EAAE,CAAC;QAE1B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACM,UAAU;QACf,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;IAEQ,MAAM;QACX,OAAO,IAAI,CAAA,eAAe,CAAC;IAC/B,CAAC;;AAGL,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,oEAAoE;AACpE,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAE3C,0EAA0E;AAC1E,cAAc,CAAC,MAAM,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC"}
+{"version":3,"file":"radio.js","sourceRoot":"","sources":["../src/radio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAuC,MAAM,KAAK,CAAC;AAC1F,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAK3C,2FAA2F;AAC3F,0FAA0F;AAC1F,2FAA2F;AAC3F,oEAAoE;AACpE,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAE1B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,IAAI,GAAG,GAAG,CAAA,kBAAkB,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC;AAElE,uFAAuF;AACvF,MAAM,KAAK,GAAG,GAAG,CAAA,6BAA6B,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,IAAI,GAAG,GAAG,CAAA,mEAAmE,CAAC;AAEpF;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,OAAQ,SAAQ,UAAU;IAAvC;;QAaI,oEAAoE;QACpE,UAAK,GAAG,EAAE,CAAC;QAEX,mFAAmF;QACnF,YAAO,GAAG,KAAK,CAAC;QAEhB,qFAAqF;QACrF,aAAQ,GAAG,KAAK,CAAC;QAeR,cAAS,GAAG,GAAS,EAAE;YAC5B,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACnE,CAAC,CAAC;IAKN,CAAC;aAzC4B,WAAM,GAAc,GAAG,CAAA;;;;KAI/C,AAJ8B,CAI7B;aAEuB,eAAU,GAAG;QAClC,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QACtC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;QACzC,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;KAC7C,AAJkC,CAIjC;IAWF;;;;;;;;OAQG;IACM,OAAO;QACZ,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IAEQ,SAAS,CAEhB;IAEO,MAAM;QACX,OAAO,IAAI,CAAA,qBAAqB,IAAI,CAAC,SAAS,UAAU,CAAC;IAC7D,CAAC;;AAGL;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IAA5C;;QAgNI;;;;;WAKG;QACH,UAAK,GAAG,EAAE,CAAC;QAEX,mFAAmF;QACnF,SAAI,GAAG,EAAE,CAAC;QAEV,gFAAgF;QAChF,UAAK,GAAG,EAAE,CAAC;QAEX;;;;;;WAMG;QACH,SAAI,GAAG,EAAE,CAAC;QAEV;;;;;;WAMG;QACH,UAAK,GAAG,EAAE,CAAC;QAEX,+EAA+E;QAC/E,gBAAW,GAAqB,UAAU,CAAC;QAE3C,yDAAyD;QACzD,aAAQ,GAAG,KAAK,CAAC;QAEjB,sEAAsE;QACtE,aAAQ,GAAG,KAAK,CAAC;QAER,eAAU,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAEpC,YAAO,GAAG,GAAS,EAAE;YAC1B,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC,CAAC;QAuEF,8DAA8D;QACrD,aAAQ,GAAG,CAAC,KAAY,EAAQ,EAAE;YACvC,IAAI,CAAC,KAAK,GAAI,KAAK,CAAC,MAA2B,CAAC,KAAK,CAAC;YACtD,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAC/D,CAAC,CAAC;IAmGN,CAAC;aA1a4B,WAAM,GAAc,GAAG,CAAA;;;2BAGzB,SAAS,CAAC,WAAW,CAAC;;;;;;;wBAOzB,SAAS,CAAC,YAAY,CAAC;;;;qBAI1B,SAAS,CAAC,iBAAiB,CAAC;;;;qBAI5B,SAAS,CAAC,uBAAuB,CAAC;;;;;;wBAM/B,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;+BAUhB,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;wBAU9B,SAAS,CAAC,YAAY,CAAC;qBAC1B,SAAS,CAAC,iBAAiB,CAAC;;;;;qBAK5B,SAAS,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;2BAkB5B,IAAI;0BACL,IAAI;;;;;gCAKE,SAAS,CAAC,oBAAoB,CAAC;;gCAE/B,SAAS,CAAC,mBAAmB,CAAC;;;;;;mCAM3B,SAAS,CAAC,qBAAqB,CAAC;sBAC7C,SAAS,CAAC,mBAAmB,CAAC;+BACrB,SAAS,CAAC,qBAAqB,CAAC,IAAI,SAAS,CAAC,mBAAmB,CAAC;;;;;;;gCAOjE,SAAS,CAAC,mBAAmB,CAAC;4BAClC,SAAS,CAAC,mBAAmB,CAAC;0BAChC,KAAK,KAAK,IAAI;;;;uBAIjB,IAAI;;;;;;;;;;;;;4BAaC,SAAS,CAAC,iBAAiB,CAAC;;;;gCAIxB,SAAS,CAAC,yBAAyB,CAAC;4BACxC,SAAS,CAAC,yBAAyB,CAAC;;;;;;;iCAO/B,SAAS,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;4BAmBlC,SAAS,CAAC,mBAAmB,CAAC;;;;qBAIrC,SAAS,CAAC,iBAAiB,CAAC;yBACxB,SAAS,CAAC,sBAAsB,CAAC;;;;;;qBAMrC,SAAS,CAAC,mBAAmB,CAAC;yBAC1B,SAAS,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;KAwBrD,AAjL8B,CAiL7B;aAEc,mBAAc,GAAG,IAAI,AAAP,CAAQ;IAEtC;;;;;OAKG;aACsB,sBAAiB,GAAG;QACzC,GAAG,UAAU,CAAC,iBAAiB;QAC/B,cAAc,EAAE,IAAI;KACvB,AAHyC,CAGxC;aAEuB,eAAU,GAAG;QAClC,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QACtC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QACrC,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QACtC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QACrC,gFAAgF;QAChF,8EAA8E;QAC9E,6EAA6E;QAC7E,mFAAmF;QACnF,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QACvB,WAAW,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;QAC5C,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;QAC1C,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;KAC7C,AAbkC,CAajC;IA2CO,UAAU,CAA0B;IAEpC,OAAO,CAEd;IAEO,iBAAiB;QACtB,KAAK,CAAC,iBAAiB,EAAE,CAAC;QAE1B,kFAAkF;QAClF,2EAA2E;QAC3E,EAAE;QACF,oFAAoF;QACpF,iFAAiF;QACjF,gEAAgE;QAChE,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,oEAAoE;IACpE,QAAQ;QACJ,OAAO,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;;OAQG;IACH,OAAO;QACH,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACxD,OAAO,IAAI,CAAC,KAAK,CAAC;QACtB,CAAC;QAED,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;IACjE,CAAC;IAED,2DAA2D;IAC3D,QAAQ,CAAC,OAAyB;QAC9B,IAAI,IAAI,CAAC,KAAK,KAAK,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAExE,OAAO;QACX,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACtF,CAAC;IAED;;;;;;;OAOG;IACM,OAAO;QACZ,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAE7C,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9D,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAEvB,OAAO;QACX,CAAC;QAED,kFAAkF;QAClF,yEAAyE;QACzE,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,8DAA8D;IACrD,QAAQ,CAGf;IAEF,uEAAuE;IACvE,iBAAiB;QACb,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,sFAAsF;IACtF,oBAAoB,CAAC,QAAiB;QAClC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAED,iFAAiF;IACjF,wBAAwB,CAAC,KAAoB;QACzC,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE,CAAC;IAC7B,CAAC;IAED,uEAAuE;IACvE,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;IAChC,CAAC;IAED,6DAA6D;IAC7D,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED,8EAA8E;IAC9E,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC;IAC7C,CAAC;IAED,sEAAsE;IACtE,UAAU;QACN,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CACjF,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CACpB,CAAC;QAEF,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAe,EAAE,MAAc;QACjC,OAAO,IAAI,CAAA;;;;uBAII,QAAQ;wBACP,MAAM,CAAC,KAAK;2BACT,MAAM,CAAC,KAAK,KAAK,MAAM;4BACtB,IAAI,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ;4BAChC,IAAI,CAAC,QAAQ;0BACf,IAAI,CAAC,QAAQ;;wCAEC,MAAM,CAAC,WAAW;iBACzC,CAAC;IACd,CAAC;IAEQ,MAAM;QACX,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE9B,OAAO,IAAI,CAAA;;8DAE2C,IAAI,CAAC,KAAK;;;;;;uCAMjC,IAAI,CAAC,WAAW;mCACpB,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;uCAChC,IAAI,CAAC,UAAU,EAAE;;sBAElC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;kBAG7D,IAAI,CAAC,IAAI,KAAK,EAAE;YACZ,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,IAAI,CAAA,4CAA4C,IAAI,CAAC,IAAI,SACnE;kBAEI,IAAI,CAAC,KAAK,KAAK,EAAE;YACb,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,IAAI,CAAA,+CAA+C,IAAI,CAAC,KAAK,SACvE;;;oCAGoB,IAAI,CAAC,OAAO;;SAEvC,CAAC;IACN,CAAC;;AAGL,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,oEAAoE;AACpE,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAE3C,0EAA0E;AAC1E,cAAc,CAAC,MAAM,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC"}