material 3.2.5 → 3.2.7

package/dist/elements/datepicker.d.ts

@@ -1,50 +1,6 @@
-/**
- * `<m-datepicker>`: the date picker as a form-associated custom element.
- *
- * The factory renders its own field, a text input with a calendar button:
- * that field is the trigger. A click on the button (or on the input of a
- * modal variant), ArrowDown in the input, the `open` attribute or `show()`
- * opens the calendar. The modal variants (`modal`, `modal-input`,
- * `fullscreen`) are a native `<dialog>` in the element's shadow root shown
- * with `showModal()`: the page outside is inert and Save commits, Cancel,
- * Escape and the backdrop do not. The docked calendar opens beside the field
- * (`show()`, not modal) and commits each date chosen.
- *
- * The value is an ISO date, `YYYY-MM-DD`, as on `<input type=date>`. With
- * `selection-mode="range"` a complete range is an ISO 8601 interval,
- * `YYYY-MM-DD/YYYY-MM-DD`: one string for the form, with a separator no date
- * contains. A lone date in range mode is a one-day range, `d/d`, as the
- * factory holds it. Empty is `""`. A value that is not one of these, or
- * that `min`, `max` or the mode rule out, empties the picker (the factory
- * keeps no such date).
- *
- * The `value` attribute is the default and the `value` property the live
- * value, as on a native input: the attribute moves the value until the user
- * or script changes it, and a form reset returns to it. `change` is
- * dispatched with `{ value }` when a date is committed. `open` reflects the
- * calendar's state, as on `<dialog open>`; `open` and `close` are dispatched
- * as it opens and closes (not when the attribute is what changed).
- *
- * `initial-view` is the view the calendar first opens on: `day`, `month` or
- * `year` (the full-screen variant has the days only). `close-on-select`
- * closes the calendar on a date chosen, committing it: a modal variant then
- * needs no Save. The factory reads both once: a change recreates the picker.
- *
- * The input of a modal variant is read-only, which takes it out of constraint
- * validation: the element reports the factory's `required` check as
- * `valueMissing`. `readonly` is the factory's: the value stays and the
- * calendar closed. `supporting-text` is the factory's supporting text.
- *
- * Parts: `datepicker`, `label`, `anchor`, `input`, `trigger`, `help`, `error`, `calendar`,
- * `header`, `navigation`, `prev`, `next`, `weekday`, `day`, among others.
- *
- * @module elements
- */
 import type { DatePickerComponent } from "../components/datepicker/types.js";
 import { type DefineOptions, type ElementHost, type ElementInstance } from "./define.js";
-/** The date picker, with what the element adds to it. */
 export interface DatepickerElementComponent extends DatePickerComponent {
-    /** Opens the calendar, unless the picker is disabled or read-only. */
     show: () => void;
 }
 declare const datepickerSpec: {
@@ -122,7 +78,10 @@ declare const datepickerSpec: {
         };
     };
     model: "value";
-    methods: readonly ["show", "close"];
+    methods: readonly [
+        "show",
+        "close"
+    ];
     events: {
         change: {
             detail: (payload: unknown) => {
@@ -151,12 +110,9 @@ declare const datepickerSpec: {
 };
 export declare const datepickerElement: import("./define.js").ElementDefinition<DatepickerElementComponent>;
 export type DatepickerSpec = typeof datepickerSpec;
-/** `<m-datepicker>` as a ref or a query returns it. */
 export type DatepickerElement = ElementInstance<DatepickerSpec, DatepickerElementComponent>;
-/** Registers `<m-datepicker>` (or `<prefix-datepicker>`). */
 export declare const defineDatepicker: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-datepicker": DatepickerElement;
     }

package/dist/elements/define.d.ts

@@ -1,26 +1,4 @@
-/**
- * `defineElement` turns a component factory into a custom element.
- *
- * The element owns one factory instance, built inside its shadow root on first
- * connection. Attributes are the component's defaults, as on native controls;
- * properties carry its live state. The model's attribute (`checked`, `value`)
- * moves the live state until the state is dirty: changed by the user or set by
- * script, as a native input's dirty value and checkedness flags. Factory
- * events are re-dispatched from the host under the same names.
- *
- * Every piece of the component is a CSS part named after its BEM class
- * without the prefix: the block by its name (`mtrl-button` is
- * `::part(button)`), an element by its element name (`mtrl-switch__track` is
- * `::part(track)`). The piece holding the slot also takes the slot
- * attribute's name, so `m-button::part(label)` is the button's label.
- *
- * Nothing here touches the DOM at import time: the element class is built on
- * first use, so every element module can be imported on a server.
- *
- * @module elements
- */
 import { DEFAULT_PREFIX } from "./styles.js";
-/** The part of a component the element relies on. */
 export interface ElementComponent {
     element: HTMLElement;
     destroy: () => void;
@@ -30,164 +8,65 @@ export type AttributeValue = string | boolean | number | null;
 export type Config = Record<string, unknown>;
 export interface AttributeSpec<C> {
     type: AttributeType;
-    /** Config key the attribute feeds at creation. Omitted: the attribute is not passed to the factory. */
     config?: string;
-    /** Applies a change after creation. Omitted: the component is recreated. */
     update?: (component: C, value: AttributeValue, host: HTMLElement) => void;
 }
 export interface PropertySpec<C> {
     get: (component: C) => unknown;
     set: (component: C, value: unknown) => void;
-    /** Config key a value set before creation feeds. */
     config?: string;
 }
 export interface EventSpec {
-    /** Maps the factory payload to the event's `detail`. Default: the payload. */
     detail?: (payload: unknown) => unknown;
-    /**
-     * The event reports a change of state beside the model (`open`,
-     * `expanded`), not of the model: dispatching it leaves the element clean.
-     */
     state?: boolean;
-    /** @internal Development diagnostic for a direct application listener. */
     listen?: (host: HTMLElement) => void;
 }
 export interface SlotSpec {
-    /** Attribute whose text is the slot's fallback content. */
     attribute: string;
-    /**
-     * The config key that takes the text or a node (`text`, `label`): the
-     * element passes its `<slot>` there and the factory places it.
-     */
     config: string;
 }
 export interface FormSpec<C> {
-    /**
-     * The value submitted with the form under the host's `name`; FormData
-     * submits its own entries instead (several values); null submits nothing.
-     */
     value: (component: C, host: HTMLElement) => string | FormData | null;
-    /** The inner control whose validity the element reports. */
     control?: (component: C) => HTMLInputElement | HTMLTextAreaElement | null;
-    /** Events after which the form value is read again. */
     events?: readonly string[];
-    /** Called when a `<label for>` or the host itself is clicked. */
     activate?: (component: C) => void;
-    /**
-     * The state the browser keeps for the control, to hand back through
-     * `restore` when it restores the form (history navigation, autofill).
-     */
     state?: (component: C) => string;
     restore?: (component: C, state: string) => void;
     disable?: (component: C, disabled: boolean) => void;
 }
-/** What a spec's `setup` sees of the element. */
 export interface ElementHost<C extends ElementComponent> extends HTMLElement {
-    /** The factory instance, while connected. */
     readonly component: C | null;
     readonly internals: ElementInternals | null;
-    /** The model was changed by the user or by script: its attributes no longer move it. */
     readonly dirty: boolean;
 }
-/**
- * What `defineElement` builds an element from: its name, the factory, the
- * styles its shadow root adopts, and how attributes, properties, slots,
- * events and the form map onto the component.
- *
- * @experimental The element authoring API (`defineElement`, `ElementSpec`,
- * `registerStyles`, `hasStyles`, `SHADOW_BASE_STYLES`) is outside semantic
- * versioning in 3.x: it may change in a minor release. The elements the
- * library defines, and their attributes, properties and events, are not.
- */
 export interface ElementSpec<C extends ElementComponent> {
-    /** Name after the prefix: "switch" registers `<m-switch>`. */
     name: string;
     create: (config: Config) => C;
-    /**
-     * Whether renderElement may build this element's shadow root. Defaults to
-     * true. False emits only the host and light DOM; a synchronous predicate
-     * can opt out based on the authored host. Browser upgrade is unchanged.
-     */
     ssr?: boolean | ((host: HTMLElement) => boolean);
-    /** Style entries, in cascade order. */
     styles: readonly string[];
-    /** CSS for the host, after the shared host rules. */
     hostStyles?: string;
-    /**
-     * A boolean attribute the host carries from the moment it connects, whatever
-     * the tag prefix it was registered under. The library's sheets are built
-     * once and cannot know the prefix a page chose, so a compound selector
-     * that must recognise one of its own hosts — `::slotted([data-…])` in
-     * another element's sheet, which cannot spell the tag — matches this
-     * instead. Server rendering writes it into the declarative markup too, so
-     * it is there at first paint, before upgrade. The attribute is the
-     * library's own, in its reserved `data-mtrl-*` namespace: it is set on
-     * connection (and again on reconnect) but not observed, so a consumer that
-     * removes it while the host stays connected also removes the matching until
-     * the host reconnects. Do not mutate it.
-     *
-     * @internal Not part of the public API and may change without notice.
-     */
     marker?: string;
     attributes?: Record<string, AttributeSpec<C>>;
     properties?: Record<string, PropertySpec<C>>;
     methods?: readonly string[];
-    /**
-     * The live property two-way binding drives (`v-model`, Svelte's `bind:`).
-     * Its attribute (the kebab-cased name) is its default: see `defaults`.
-     */
     model?: string;
-    /**
-     * Live properties beyond `model` whose attribute is their default the same
-     * way (the slider's `secondValue` and `second-value`). A change of such an
-     * attribute moves the live state until the element is dirty, and a form
-     * reset returns to it.
-     */
     defaults?: readonly string[];
     events?: Record<string, EventSpec>;
     slot?: SlotSpec;
-    /**
-     * The named slots the element reads: a child with `slot="<name>"` goes
-     * there. Declared `as const`, so the adapters type them (a Svelte snippet,
-     * a Vue slot) and describe() lists them. check-elements proves each is
-     * read and none other is.
-     */
     slots?: readonly string[];
     form?: FormSpec<C>;
-    /** Extra config read from the host, such as children. */
     config?: (host: HTMLElement) => Config;
-    /** Wiring that lives as long as one component; returns its cleanup. */
     setup?: (host: ElementHost<C>, component: C) => (() => void) | void;
-    /**
-     * React to the host's children changing. `true` recreates the component; a
-     * function updates it in place and returns false when it cannot, which
-     * falls back to recreating.
-     */
     observeChildren?: boolean | ((host: ElementHost<C>, component: C) => boolean);
 }
 export interface DefineOptions {
-    /** Tag prefix, without the dash. Default "m". */
     prefix?: string;
 }
 export { DEFAULT_PREFIX };
-/**
- * Global base styles components rely on, which a shadow root does not inherit.
- * Registered under these names like the component entries.
- *
- * @experimental The element authoring API (`defineElement`, `ElementSpec`,
- * `registerStyles`, `hasStyles`, `SHADOW_BASE_STYLES`) is outside semantic
- * versioning in 3.x: it may change in a minor release. The elements the
- * library defines, and their attributes, properties and events, are not.
- */
-export declare const SHADOW_BASE_STYLES: readonly ["ripple"];
+export declare const SHADOW_BASE_STYLES: readonly [
+    "ripple"
+];
 export declare const BASE_HOST_STYLES: string;
-/**
- * Internal shared host CSS, in browser cascade order. Beside a bare `:host`
- * display rule the base display declaration is dead (the later rule wins at
- * equal specificity) and would ride in every server-rendered root's inline
- * sheet, so it is not shipped for such an element — today the button (#42)
- * and the switch, whose inline-flex rule has made it dead since it landed.
- */
 export declare const hostStyleText: (spec: {
     hostStyles?: string;
 }) => string;
@@ -196,28 +75,21 @@ type ValueOf<T> = T extends "boolean" ? boolean : T extends "number" ? number :
 type Get<S, K extends string> = S extends {
     [P in K]: infer V;
 } ? V : Record<never, never>;
-/** Attributes as properties, camelCased: `supporting-text` is `supportingText`. */
 export type ElementAttributes<S> = {
     [K in keyof Get<S, "attributes"> & string as Camel<K>]?: Get<S, "attributes">[K] extends {
         type: infer T;
     } ? ValueOf<T> : never;
 };
-/**
- * Attributes as markup writes them (`supporting-text`), for a bare `m-*` tag
- * in JSX (`material/react/jsx`, `material/solid/jsx`).
- */
 export type ElementMarkup<S> = {
     [K in keyof Get<S, "attributes"> & string]?: Get<S, "attributes">[K] extends {
         type: infer T;
     } ? ValueOf<T> : never;
 } & ElementSlotText<S>;
-/** Live-state properties, typed by their getter. */
 export type ElementProperties<S> = {
     [K in keyof Get<S, "properties"> & string]?: Get<S, "properties">[K] extends {
         get: (c: never) => infer R;
     } ? R : unknown;
 };
-/** The slot's fallback-text attribute, when the spec has one. */
 export type ElementSlotText<S> = S extends {
     slot: {
         attribute: infer A extends string;
@@ -225,59 +97,29 @@ export type ElementSlotText<S> = S extends {
 } ? string extends A ? Record<never, never> : {
     [K in A]?: string;
 } : Record<never, never>;
-/** Event names to their `CustomEvent`, typed by the spec's `detail` mapper. */
 export type ElementEvents<S> = {
     [K in keyof Get<S, "events"> & string]: CustomEvent<Get<S, "events">[K] extends {
         detail: (p: never) => infer D;
     } ? D : unknown>;
 };
-/** Methods the element forwards to its component. */
 export type ElementMethods<S, C> = S extends {
     methods: readonly (infer M)[];
 } ? string extends M ? Record<never, never> : {
     [K in M & keyof C & string]: C[K] extends (...args: infer A) => unknown ? (...args: A) => unknown : never;
 } : Record<never, never>;
-/**
- * Every property an element instance has, beyond HTMLElement's. A live-state
- * property replaces the attribute of the same name: the `checked` property is
- * the switch's current state, the `checked` attribute only its default.
- */
 export type ElementProps<S> = Omit<ElementAttributes<S>, keyof ElementProperties<S>> & ElementProperties<S> & ElementSlotText<S>;
-/** The names of the element's named slots, from its spec's `slots`. */
 export type ElementSlots<S> = S extends {
     slots: readonly (infer N extends string)[];
 } ? N : never;
-/** A named slot as a prop name (`header-action` → `headerAction`), for adapters whose slots are props. */
 export type ElementSlotProp<S> = Camel<ElementSlots<S>>;
-/** An element instance, as a ref or `document.querySelector` returns it. */
 export type ElementInstance<S, C extends ElementComponent> = ElementHost<C> & ElementProps<S> & ElementMethods<S, C>;
-/** The element class for a spec. Called on first use, never at import. */
 export declare const createElementClass: <C extends ElementComponent>(spec: ElementSpec<C>) => CustomElementConstructor;
-/**
- * The class of a declaration element (`<m-tab>`): it renders nothing, and each
- * declared attribute has a property that reads and writes it. Frameworks that set
- * a custom element's props as properties (Solid always does) then reach the
- * attributes its parent reads, as frameworks that set attributes already did.
- * Called on first use, never at import.
- */
 export declare const createDeclarationClass: (attributes: Record<string, {
     type: AttributeType;
 }>) => CustomElementConstructor;
-/** A spec with its element class and registration. */
 export interface ElementDefinition<C extends ElementComponent> {
     spec: ElementSpec<C>;
-    /** The element class, built on first access. Browser only. */
     readonly element: CustomElementConstructor;
-    /** Registers the element; a repeated call is a no-op. Returns the tag. Browser only. */
     define: (options?: DefineOptions) => string;
 }
-/**
- * Creates the definition for a spec. Nothing is built or registered until
- * `element` or `define()` is used, so the module can be imported on a server.
- *
- * @experimental The element authoring API (`defineElement`, `ElementSpec`,
- * `registerStyles`, `hasStyles`, `SHADOW_BASE_STYLES`) is outside semantic
- * versioning in 3.x: it may change in a minor release. The elements the
- * library defines, and their attributes, properties and events, are not.
- */
 export declare const defineElement: <C extends ElementComponent>(spec: ElementSpec<C>) => ElementDefinition<C>;

package/dist/elements/dialog.d.ts

@@ -1,45 +1,14 @@
-/**
- * `<m-dialog>`: the dialog as a custom element. It is the factory's top-layer
- * dialog (`layer: "top"`): a native `<dialog>` in the element's shadow root,
- * shown with `showModal()`, so it sits above every z-index and outside any
- * clipping ancestor, the page outside is inert, and the scrim is its
- * `::backdrop`. Its regions are slots:
- *
- * - `headline`: the headline, which names the dialog (the `headline`
- *   attribute is its fallback text); without one, `aria-label` names it;
- * - the default slot: the supporting content, which describes it;
- * - `actions`: the buttons, at the end.
- *
- * `open` shows it and reflects its state, as on `<dialog open>`: Escape, a
- * click on the backdrop, the full-screen close button and `close()` remove
- * it. `show()` and `close()` are its methods. `open` and `close` are
- * dispatched as it opens and closes (not when the attribute is what changed),
- * and `cancel` when Escape asks it to close, which `preventDefault()` refuses.
- * `size` is the factory's (`small`, `medium`, `large`, `fullwidth`,
- * `fullscreen`), and `fullscreen` the full-screen dialog whatever `size`
- * says; a full-screen dialog has the close button, which `close-button`
- * gives any size. `subtitle` is the text below the headline, `divider`
- * draws the dividers above and below the content, and `footer-alignment`
- * places the actions (`right`, `left`, `center`, `space-between`).
- * `animation` is the factory's (`scale`, `slide-up`, `slide-down`, `fade`);
- * the factory reads it once, so a change recreates the dialog.
- * `no-close-on-scrim-click` and `no-close-on-escape` keep it open on a click
- * on the backdrop and on Escape (the factory's `closeOnOverlayClick` and
- * `closeOnEscape`); `cancel` is still dispatched on Escape.
- *
- * Parts: `dialog`, `header`, `header-content`, `header-title`, `content`, `footer`.
- *
- * @module elements
- */
 import type { DialogComponent } from "../components/dialog/types.js";
 import { type DefineOptions, type ElementInstance } from "./define.js";
-/** The dialog with the `show()` the element names after `<dialog>`'s. */
 export interface DialogElementComponent extends DialogComponent {
     show: () => DialogComponent;
 }
 declare const dialogSpec: {
     name: string;
-    slots: readonly ["headline", "actions"];
+    slots: readonly [
+        "headline",
+        "actions"
+    ];
     create: (config: import("./define.js").Config) => DialogElementComponent;
     styles: string[];
     hostStyles: string;
@@ -96,7 +65,10 @@ declare const dialogSpec: {
             update: (c: DialogElementComponent, _v: import("./define.js").AttributeValue, host: HTMLElement) => void;
         };
     };
-    methods: readonly ["show", "close"];
+    methods: readonly [
+        "show",
+        "close"
+    ];
     events: {
         open: {
             detail: () => null;
@@ -114,12 +86,9 @@ declare const dialogSpec: {
 };
 export declare const dialogElement: import("./define.js").ElementDefinition<DialogElementComponent>;
 export type DialogSpec = typeof dialogSpec;
-/** `<m-dialog>` as a ref or a query returns it. */
 export type DialogElement = ElementInstance<DialogSpec, DialogElementComponent>;
-/** Registers `<m-dialog>` (or `<prefix-dialog>`). */
 export declare const defineDialog: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-dialog": DialogElement;
     }

package/dist/elements/divider.d.ts

@@ -1,14 +1,3 @@
-/**
- * `<m-divider>`: the divider as a custom element. The factory renders an
- * `<hr>`, a separator, with `aria-orientation` when vertical.
- *
- * A horizontal divider fills its line; a vertical one stretches with its flex
- * or grid row.
- *
- * Parts: `divider`.
- *
- * @module elements
- */
 import type { DividerComponent } from "../components/divider/types.js";
 import { type DefineOptions, type ElementInstance } from "./define.js";
 declare const dividerSpec: {
@@ -49,12 +38,9 @@ declare const dividerSpec: {
 };
 export declare const dividerElement: import("./define.js").ElementDefinition<DividerComponent>;
 export type DividerSpec = typeof dividerSpec;
-/** `<m-divider>` as a ref or a query returns it. */
 export type DividerElement = ElementInstance<DividerSpec, DividerComponent>;
-/** Registers `<m-divider>` (or `<prefix-divider>`). */
 export declare const defineDivider: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-divider": DividerElement;
     }

package/dist/elements/drawer.d.ts

@@ -1,30 +1,3 @@
-/**
- * `<m-drawer>` with `<m-drawer-item>` children: the standard (in-page)
- * navigation drawer.
- *
- * Each `<m-drawer-item>` declares one destination (`value`, `icon`, `badge`,
- * `disabled`, and its text as the label), or with `type="section"` a section
- * headline (its text) and with `type="divider"` a divider. The drawer reads
- * them into the factory's config and updates in place when they change; the
- * children stay where the framework put them. `value` on the drawer is the
- * default destination, which moves the live one until the user or script
- * changes it; the `value` property is the live one.
- *
- * `open` shows the drawer, as on the factory: without it the drawer is
- * collapsed to no width and inert. `modal` makes it the modal drawer in the
- * factory's top layer (`layer: "top"`): a native `<dialog>` in the element's
- * shadow root, shown with `showModal()`, above every z-index, the page
- * outside inert, the scrim its `::backdrop`. Escape and a click on the
- * backdrop close it, and `open` then reflects its state;
- * `no-close-on-scrim-click` and `no-close-on-escape` keep it open instead. `open` and `close`
- * are dispatched as it opens and closes (not when the attribute is what
- * changed).
- *
- * Parts: `drawer`, `sheet`, `items`, `item`, `active-indicator`, `item-icon`, `item-label`,
- * `ripple`.
- *
- * @module elements
- */
 import type { DrawerComponent } from "../components/drawer/types.js";
 import { type Config, type DefineOptions, type ElementAttributes, type ElementHost, type ElementInstance } from "./define.js";
 declare const drawerSpec: {
@@ -105,12 +78,7 @@ declare const drawerSpec: {
 };
 export declare const drawerElement: import("./define.js").ElementDefinition<DrawerComponent>;
 export type DrawerSpec = typeof drawerSpec;
-/** `<m-drawer>` as a ref or a query returns it. */
 export type DrawerElement = ElementInstance<DrawerSpec, DrawerComponent>;
-/**
- * `<m-drawer-item>` declares one destination, section headline or divider,
- * and renders nothing. Its text content is the label unless `label` is set.
- */
 export declare const drawerItemDeclaration: {
     readonly name: "drawer-item";
     readonly attributes: {
@@ -123,7 +91,6 @@ export declare const drawerItemDeclaration: {
         readonly label: {
             readonly type: "string";
         };
-        /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. */
         readonly icon: {
             readonly type: "string";
         };
@@ -136,10 +103,8 @@ export declare const drawerItemDeclaration: {
     };
 };
 export type DrawerItemAttributes = ElementAttributes<typeof drawerItemDeclaration>;
-/** Registers `<m-drawer>` and `<m-drawer-item>` (or with another prefix). */
 export declare const defineDrawer: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-drawer": DrawerElement;
         "m-drawer-item": HTMLElement & DrawerItemAttributes;

package/dist/elements/extended-fab.d.ts

@@ -1,16 +1,3 @@
-/**
- * `<m-extended-fab>`: the extended floating action button as a custom
- * element. Children are the label.
- *
- * `variant`, `size`, `width`, `icon-position`, `position`,
- * `collapse-on-scroll` and `aria-label` have no setter on the extended FAB:
- * changing one recreates it. `type="submit"` and `type="reset"` act on the
- * host's form.
- *
- * Parts: `extended-fab`, `icon`, `label` (also `text`), `ripple`.
- *
- * @module elements
- */
 import type { ExtendedFabComponent } from "../components/extended-fab/types.js";
 import { type DefineOptions, type ElementInstance } from "./define.js";
 declare const extendedFabSpec: {
@@ -36,7 +23,6 @@ declare const extendedFabSpec: {
             config: string;
             update: (c: ExtendedFabComponent, v: import("./define.js").AttributeValue) => undefined;
         };
-        /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. */
         icon: {
             type: "string";
             config: string;
@@ -68,7 +54,12 @@ declare const extendedFabSpec: {
             config: string;
         };
     };
-    methods: readonly ["lower", "raise", "collapse", "expand"];
+    methods: readonly [
+        "lower",
+        "raise",
+        "collapse",
+        "expand"
+    ];
     events: {
         collapse: {
             detail: () => null;
@@ -86,12 +77,9 @@ declare const extendedFabSpec: {
 };
 export declare const extendedFabElement: import("./define.js").ElementDefinition<ExtendedFabComponent>;
 export type ExtendedFabSpec = typeof extendedFabSpec;
-/** `<m-extended-fab>` as a ref or a query returns it. */
 export type ExtendedFabElement = ElementInstance<ExtendedFabSpec, ExtendedFabComponent>;
-/** Registers `<m-extended-fab>` (or `<prefix-extended-fab>`). */
 export declare const defineExtendedFab: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-extended-fab": ExtendedFabElement;
     }

package/dist/elements/fab-menu.d.ts

@@ -1,30 +1,7 @@
-/**
- * `<m-fab-menu>` with `<m-fab-menu-item>` children.
- *
- * Each `<m-fab-menu-item>` declares one action: its text (or `label`),
- * `value` and `icon`. The FAB takes `icon` and `aria-label`, which names the
- * menu it opens. `color`, `size`, `presentation` and `placement` are the
- * factory's options: the expressive list below 600px, the baseline menu from
- * 600px, unless `presentation` says otherwise.
- *
- * `open` is state, as on `<m-menu>`: the attribute reflects whether the menu
- * is open, and setting or removing it opens or closes it. `show()`, `hide()`
- * and `toggle()` do the same. `open` and `close` are dispatched as it opens
- * and closes, by those methods or the user (not when the attribute or the
- * property is what changed: that is applied at once, and quietly), and
- * `select` with the item's value when one is chosen.
- *
- * Parts: `fab-menu`, `fab`, `list`, `item`.
- *
- * @module elements
- */
 import type { FabMenuComponent } from "../components/fab-menu/types.js";
 import { type Config, type DefineOptions, type ElementAttributes, type ElementInstance } from "./define.js";
-/** The FAB menu, with the methods the element adds to it. */
 export type FabMenuElementComponent = FabMenuComponent & {
-    /** Opens the menu. */
     show: () => void;
-    /** Closes the menu. */
     hide: () => void;
 };
 declare const fabMenuSpec: {
@@ -37,7 +14,6 @@ declare const fabMenuSpec: {
             type: "boolean";
             update: (c: FabMenuElementComponent, v: import("./define.js").AttributeValue) => void;
         };
-        /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. The menu opts out of server rendering, so the server leaves this escaped until the component upgrades. */
         icon: {
             type: "string";
             config: string;
@@ -64,7 +40,11 @@ declare const fabMenuSpec: {
             config: string;
         };
     };
-    methods: readonly ["show", "hide", "toggle"];
+    methods: readonly [
+        "show",
+        "hide",
+        "toggle"
+    ];
     events: {
         open: {
             detail: () => {};
@@ -86,9 +66,7 @@ declare const fabMenuSpec: {
 };
 export declare const fabMenuElement: import("./define.js").ElementDefinition<FabMenuElementComponent>;
 export type FabMenuSpec = typeof fabMenuSpec;
-/** `<m-fab-menu>` as a ref or a query returns it. */
 export type FabMenuElement = ElementInstance<FabMenuSpec, FabMenuElementComponent>;
-/** `<m-fab-menu-item>` declares one action and renders nothing. Its text is the label unless `label` is set. */
 export declare const fabMenuItemDeclaration: {
     readonly name: "fab-menu-item";
     readonly attributes: {
@@ -98,17 +76,14 @@ export declare const fabMenuItemDeclaration: {
         readonly label: {
             readonly type: "string";
         };
-        /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. The menu opts out of server rendering, so the server leaves this escaped until the component upgrades. */
         readonly icon: {
             readonly type: "string";
         };
     };
 };
 export type FabMenuItemAttributes = ElementAttributes<typeof fabMenuItemDeclaration>;
-/** Registers `<m-fab-menu>` and `<m-fab-menu-item>` (or with another prefix). */
 export declare const defineFabMenu: (options?: DefineOptions) => string;
 declare global {
-    /** `document.querySelector("m-…")` and `createElement` return the element's type (the default prefix). */
     interface HTMLElementTagNameMap {
         "m-fab-menu": FabMenuElement;
         "m-fab-menu-item": HTMLElement & FabMenuItemAttributes;