material 3.2.6 → 3.3.0

package/dist/core/dom/layer.d.ts

@@ -1,117 +1,19 @@
-/**
- * How an element is promoted to the browser's top layer:
- * - `popover-auto`: `popover="auto"`, which the browser light-dismisses (a
- *   click outside, Escape, another auto popover opening)
- * - `popover-manual`: `popover="manual"`, closed only by its owner
- * - `modal`: a `<dialog>` shown with `showModal()`, which makes the rest of
- *   the page inert and closes on Escape
- */
 export type TopLayerKind = "popover-auto" | "popover-manual" | "modal";
 export interface TopLayerOptions {
     kind: TopLayerKind;
 }
-/**
- * Whether the browser can show an element of this kind in the top layer:
- * `showPopover` for the popovers, `HTMLDialogElement.prototype.showModal` for
- * a modal.
- *
- * @param kind - The kind of top-layer element
- * @returns True where the browser supports it
- */
 export declare const supportsTopLayer: (kind: TopLayerKind) => boolean;
-/**
- * Shows an element in the top layer, above everything else on the page
- * whatever its z-index and whatever clips or transforms its ancestors. The
- * element stays where it is in the DOM, so it keeps the styles of its tree,
- * a shadow root's included.
- *
- * The element must be connected, and for `modal` be a `<dialog>`. Showing an
- * element already shown does nothing.
- *
- * Where the browser has no support for the kind, nothing changes and false is
- * returned: the caller keeps its own positioning and stacking, which is what
- * it did before the top layer.
- *
- * @param element - The element to show
- * @param options - The kind of top-layer element
- * @returns True when the element is in the top layer
- */
 export declare const showInTopLayer: (element: HTMLElement, { kind }: TopLayerOptions) => boolean;
-/**
- * Takes an element out of the top layer. Does nothing when it is not shown.
- * This close is not reported to onTopLayerClose.
- *
- * @param element - The element shown with showInTopLayer
- */
 export declare const hideFromTopLayer: (element: HTMLElement) => void;
-/**
- * Reports the closes the browser makes on its own: a light dismiss or Escape
- * for `popover="auto"` (a `toggle` event to `closed`), Escape or a form for a
- * modal dialog (its `close` event, which follows an uncanceled `cancel`).
- * Closes made with hideFromTopLayer are not reported, nor is a close the
- * element was shown again after.
- *
- * @param element - The element shown with showInTopLayer
- * @param callback - Called once for each close
- * @returns A function that stops the reports
- */
 export declare const onTopLayerClose: (element: HTMLElement, callback: () => void) => (() => void);
-/**
- * A modal outside the top layer: makes everything but `keep` inert,
- * as showModal() does for a top-layer dialog. The siblings of `keep` and of
- * each of its ancestors, up to the body, crossing shadow roots, get `inert`;
- * elements already inert are left alone. Returns the undo, which removes
- * `inert` from exactly the elements it set it on.
- */
 export declare const inertOutside: (keep: Element) => (() => void);
-/** What eventsFrom returns: see there. */
 export interface EventsFrom {
-    /** Whether the event's dispatch began after the call */
     after: (event: Event) => boolean;
-    /** Releases the marker. Harmless when called again. */
     stop: () => void;
 }
-/**
- * Tells the events that came after this call from the one that was already
- * on its way: "the event that opened an overlay never dismisses it".
- *
- * An overlay adds its dismiss listeners in `open()`, and the click or the key
- * press that called `open()` then reaches them, on its way up. It is not
- * told apart by time (event times are whole milliseconds in some browsers,
- * and equal times cannot be ordered) nor by the task (a real key press can
- * be delivered before any timer has run), but by the dispatch itself: every
- * event passes the window's capture phase first, where one listener numbers
- * it. An event numbered after the call came after it; the one in flight has
- * an earlier number, or none.
- *
- * The browser's own `cancel` for a modal `<dialog>` is not covered: it is a
- * new event, created after `open()` (see `ModalEscape.opening`).
- *
- * @param element - An element of the overlay, which says which window it is in
- * @returns `after(event)`, and `stop()` for when the overlay closes
- */
 export declare const eventsFrom: (element: HTMLElement) => EventsFrom;
-/** A modal's place in the Escape stack: see onModalEscape. */
 export interface ModalEscape {
-    /**
-     * True for the rest of the task the modal opened in, for the one event the
-     * marker cannot number: the `cancel` the browser sends the topmost modal
-     * `<dialog>` for the key press that opened it, when the page stopped that
-     * key press before it reached the window.
-     */
     opening: boolean;
-    /** Takes the modal off the stack. Harmless when called again. */
     stop: () => void;
 }
-/**
- * Escape for a modal, handled as a key press. One bubble listener on the
- * window serves every open modal: after the listeners on the document, so
- * whatever is open inside the modal keeps a key it has used, and wherever
- * focus is, the body included. Only the topmost modal is told, and never for
- * the key press that opened it (see eventsFrom).
- *
- * @param element - The modal's element, which says which window it is in
- * @param escape - Called for an Escape that is the modal's: it closes, or refuses
- * @returns The modal's entry: `opening`, and `stop()` for when it closes
- */
 export declare const onModalEscape: (element: HTMLElement, escape: () => void) => ModalEscape;

package/dist/core/dom/roving.d.ts

@@ -1,30 +1,11 @@
-/**
- * Whether the arrow keys, Home and End belong to an element: a text input, a
- * textarea or editable content, where they move the caret.
- */
 export declare const isTextEditable: (element: EventTarget | null | undefined) => boolean;
 export interface RovingOptions {
-    /** The composite: it receives the key and focus listeners. */
     container: HTMLElement;
-    /**
-     * The focus targets in order. A target is an element that takes focus itself:
-     * a control, or the host of a web component that delegates focus to one.
-     */
     targets: () => HTMLElement[];
-    /** Whether Up and Down move focus instead of Left and Right. */
     vertical?: () => boolean;
 }
 export interface Roving {
-    /** Puts the one tab stop back on the current target, or the first enabled one. */
     sync(): void;
-    /** Removes the listeners. */
     destroy(): void;
 }
-/**
- * A roving tab index over a composite's focus targets (the WAI-ARIA toolbar
- * pattern): one tab stop, kept on the target focused last; the arrow keys along
- * the layout, Left and Right following the reading direction; Home and End to
- * the ends. Disabled targets are skipped and the ends do not wrap. Inside a
- * text input the keys stay with the caret.
- */
 export declare const createRoving: ({ container, targets, vertical }: RovingOptions) => Roving;

package/dist/core/index.d.ts

@@ -1,12 +1,3 @@
-/**
- * @module core
- * @description Core utilities and building blocks for the component system
- *
- * This module provides the foundational elements used to build components
- * in a functional, composable way.
- *
- * @packageDocumentation
- */
 export * from "./compose/index.js";
 export * from "./dom/index.js";
 export { schemeToTokens, THEME_ROLES } from "./theme/index.js";

package/dist/core/navigation/destinations.d.ts

@@ -1,42 +1,19 @@
-/** One destination, as both components take it. */
 export interface DestinationConfig {
     id: string;
     label: string;
-    /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. */
     icon: string;
-    /** Markup (HTML). Not sanitized by default: see Markup and sanitizing. Shown while this destination is active. */
     activeIcon?: string;
     href?: string;
-    /** A count, a short text, or `true` for the dot */
     badge?: string | number | boolean;
     badgeLabel?: string;
     active?: boolean;
     disabled?: boolean;
 }
-/** The component's class for a part: `__item`, `__badge`, … */
 export type PartClass = (part: string) => string;
-/** A copy of the items with unique ids, labels and icons, and one active at most. */
 export declare const copyDestinations: <T extends DestinationConfig>(items: T[], component: string) => T[];
-/**
- * Shows, updates or removes the item's badge, and names the destination with
- * it. The name carries what the badge shows: a count past the badge's maximum
- * reads "999+" in both, an empty or zero count clears the badge, and a dot
- * with no label of its own announces "New notification" — "The accessibility
- * label for a badge item will be read after its navigation destination. Any
- * numerical badges will have their number read, while non-counting badges will
- * simply announce New notification" (m3.material.io/components/badges/
- * accessibility, Labeling elements).
- */
 export declare const updateBadge: (item: DestinationConfig, element: HTMLElement, cls: PartClass) => void;
-/** The destination's element: a link or a button, its indicator, icon, label and badge. */
 export declare const createDestination: (item: DestinationConfig, cls: PartClass) => HTMLElement;
-/** Marks the active destination, and shows its active icon. */
 export declare const updateSelection: (items: DestinationConfig[], nodes: Map<string, HTMLElement>, cls: PartClass) => void;
-/**
- * Moves focus between the enabled destinations: `next` and `previous` are the
- * arrow keys of the component's axis, Home and End go to the ends. Returns
- * whether it moved.
- */
 export declare const moveDestinationFocus: (event: KeyboardEvent, nodes: Map<string, HTMLElement>, container: HTMLElement, keys: {
     next: string;
     previous: string;

package/dist/core/shapes/cubic.d.ts

@@ -1,32 +1,37 @@
-/** A cubic Bézier: anchor 0, control 0, control 1, anchor 1 */
-export type Cubic = readonly [number, number, number, number, number, number, number, number];
-/** A 2D point */
-export type Point = readonly [number, number];
-/** Below this distance two points are the same point */
+export type Cubic = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export type Point = readonly [
+    number,
+    number
+];
 export declare const DISTANCE_EPSILON = 0.0001;
 export declare const lerp: (start: number, stop: number, fraction: number) => number;
 export declare const distance: (x: number, y: number) => number;
-/** Unit vector in the direction of (x, y) */
 export declare const direction: (x: number, y: number) => Point;
 export declare const rotate90: ([x, y]: Point) => Point;
 export declare const dot: (a: Point, b: Point) => number;
-/** A straight segment expressed as a cubic */
 export declare const straightLine: (x0: number, y0: number, x1: number, y1: number) => Cubic;
-/**
- * A circular arc from (x0, y0) to (x1, y1) around (centerX, centerY),
- * approximated by one cubic; the arc must be under 180 degrees.
- */
 export declare const circularArc: (centerX: number, centerY: number, x0: number, y0: number, x1: number, y1: number) => Cubic;
 export declare const pointOnCurve: (c: Cubic, t: number) => Point;
-/** Splits a cubic at `t` into two that together trace it (de Casteljau) */
-export declare const splitCubic: (c: Cubic, t: number) => [Cubic, Cubic];
+export declare const splitCubic: (c: Cubic, t: number) => [
+    Cubic,
+    Cubic
+];
 export declare const reverseCubic: (c: Cubic) => Cubic;
 export declare const zeroLength: (c: Cubic) => boolean;
 export type PointTransformer = (x: number, y: number) => Point;
 export declare const transformCubic: (c: Cubic, f: PointTransformer) => Cubic;
-/**
- * The bounding box of a cubic as [left, top, right, bottom]. The approximate
- * box is the hull of anchors and controls, which is what the library uses to
- * normalise shapes.
- */
-export declare const cubicBounds: (c: Cubic) => [number, number, number, number];
+export declare const cubicBounds: (c: Cubic) => [
+    number,
+    number,
+    number,
+    number
+];

package/dist/core/shapes/material.d.ts

@@ -1,73 +1,38 @@
 import { RoundedPolygon, polygonMaxRadius } from "./polygon.js";
-/** Circle */
 export declare const shapeCircle: () => RoundedPolygon;
-/** A rounded square */
 export declare const shapeSquare: () => RoundedPolygon;
-/** A slanted square */
 export declare const shapeSlanted: () => RoundedPolygon;
-/** An arch */
 export declare const shapeArch: () => RoundedPolygon;
-/** A fan */
 export declare const shapeFan: () => RoundedPolygon;
-/** An arrow */
 export declare const shapeArrow: () => RoundedPolygon;
-/** A semicircle */
 export declare const shapeSemiCircle: () => RoundedPolygon;
-/** An oval */
 export declare const shapeOval: () => RoundedPolygon;
-/** A pill */
 export declare const shapePill: () => RoundedPolygon;
-/** A triangle */
 export declare const shapeTriangle: () => RoundedPolygon;
-/** A diamond */
 export declare const shapeDiamond: () => RoundedPolygon;
-/** A clam shell */
 export declare const shapeClamShell: () => RoundedPolygon;
-/** A pentagon */
 export declare const shapePentagon: () => RoundedPolygon;
-/** A gem */
 export declare const shapeGem: () => RoundedPolygon;
-/** A sunny shape: an 8-point star */
 export declare const shapeSunny: () => RoundedPolygon;
-/** A very sunny shape */
 export declare const shapeVerySunny: () => RoundedPolygon;
-/** A 4-sided cookie */
 export declare const shapeCookie4Sided: () => RoundedPolygon;
-/** A 6-sided cookie */
 export declare const shapeCookie6Sided: () => RoundedPolygon;
-/** A 7-sided cookie */
 export declare const shapeCookie7Sided: () => RoundedPolygon;
-/** A 9-sided cookie */
 export declare const shapeCookie9Sided: () => RoundedPolygon;
-/** A 12-sided cookie */
 export declare const shapeCookie12Sided: () => RoundedPolygon;
-/** A ghost-ish shape */
 export declare const shapeGhostish: () => RoundedPolygon;
-/** A 4-leaf clover */
 export declare const shapeClover4Leaf: () => RoundedPolygon;
-/** An 8-leaf clover */
 export declare const shapeClover8Leaf: () => RoundedPolygon;
-/** A burst */
 export declare const shapeBurst: () => RoundedPolygon;
-/** A soft burst */
 export declare const shapeSoftBurst: () => RoundedPolygon;
-/** A boom */
 export declare const shapeBoom: () => RoundedPolygon;
-/** A soft boom */
 export declare const shapeSoftBoom: () => RoundedPolygon;
-/** A flower */
 export declare const shapeFlower: () => RoundedPolygon;
-/** A puffy shape */
 export declare const shapePuffy: () => RoundedPolygon;
-/** A puffy diamond */
 export declare const shapePuffyDiamond: () => RoundedPolygon;
-/** A pixelated circle */
 export declare const shapePixelCircle: () => RoundedPolygon;
-/** A pixelated triangle */
 export declare const shapePixelTriangle: () => RoundedPolygon;
-/** A bun */
 export declare const shapeBun: () => RoundedPolygon;
-/** A heart */
 export declare const shapeHeart: () => RoundedPolygon;
 declare const byName: {
     circle: () => RoundedPolygon;
@@ -106,45 +71,16 @@ declare const byName: {
     bun: () => RoundedPolygon;
     heart: () => RoundedPolygon;
 };
-/**
- * Names of the Material shapes: Compose's, camelCased. material 3.0.0 removed 0.10's
- * 'cookie4' and 'cookie9' aliases: use 'cookie4Sided' and 'cookie9Sided'.
- */
 export type MaterialShapeName = keyof typeof byName;
-/** A Material shape by name, normalised into the unit square. Carries every shape; import `shapeX` to carry one. */
 export declare const materialShape: (name: MaterialShapeName) => RoundedPolygon;
-/**
- * A polygon's outline as an SVG path ("M … C … Z"), scaled by `size`: a
- * normalised shape fills a `size` × `size` box. Coordinates keep three decimals.
- */
 export declare const polygonPath: (polygon: RoundedPolygon, size?: number) => string;
-/** A Material shape as an SVG path in a `size` × `size` box. Carries every shape, as materialShape does. */
 export declare const materialShapePath: (name: MaterialShapeName, size?: number) => string;
-/** A shape's outline as radii at evenly spaced angles around its centre */
 export interface RadialProfile {
-    /** Radius at angle i * 2π / radii.length, clockwise from the positive x axis on a y-down canvas */
     radii: Float32Array;
-    /** The area centroid the radii are measured from */
     centerX: number;
     centerY: number;
-    /** The largest radius, for fitting the shape into a circle */
     maxRadius: number;
 }
-/**
- * radialProfile without its star-shape check, for callers whose shapes are
- * known to be star-shaped: the loading indicator's, which the tests check.
- * The centroid, not the bounds centre, is the pivot: a pentagon's mass sits
- * below the middle of its box, and turning it about the box would make it
- * orbit.
- * @internal
- */
 export declare const sampleProfile: (polygon: RoundedPolygon, samples?: number, stepsPerCubic?: number) => RadialProfile;
-/**
- * Samples the outline at `samples` angles around the shape's area centroid.
- * Throws for a shape that is not star-shaped around it. Of the Material
- * shapes, 33 are; Puffy and PixelTriangle are not (their outlines double back
- * as seen from the centroid, Puffy by about 0.1°): a ray from the centroid
- * would cross the outline more than once, and the profile would be wrong.
- */
 export declare const radialProfile: (polygon: RoundedPolygon, samples?: number, stepsPerCubic?: number) => RadialProfile;
 export { polygonMaxRadius };

package/dist/core/shapes/polygon.d.ts

@@ -1,37 +1,27 @@
 import { Cubic, PointTransformer } from "./cubic.js";
-/** How a vertex is rounded: the radius, and how much the curve is smoothed into the sides (0–1) */
 export interface CornerRounding {
     radius: number;
     smoothing?: number;
 }
 export declare const UNROUNDED: CornerRounding;
-/** A closed shape made of contiguous cubics */
 export interface RoundedPolygon {
     cubics: Cubic[];
     centerX: number;
     centerY: number;
 }
-/**
- * Builds a rounded polygon from a flat list of vertex coordinates
- * [x0, y0, x1, y1, ...], a rounding for every vertex or one per vertex, and
- * an optional centre (the vertices' centroid by default).
- */
 export declare const roundedPolygon: (vertices: number[], rounding?: CornerRounding, perVertexRounding?: CornerRounding[], centerX?: number, centerY?: number) => RoundedPolygon;
-/** A regular polygon, first vertex at angle 0 */
 export declare const regularPolygon: (numVertices: number, radius?: number, centerX?: number, centerY?: number, rounding?: CornerRounding, perVertexRounding?: CornerRounding[]) => RoundedPolygon;
-/** A circle approximated by a fully rounded polygon */
 export declare const circle: (numVertices?: number, radius?: number, centerX?: number, centerY?: number) => RoundedPolygon;
-/** A star with `numVerticesPerRadius` outer and inner vertices, outer first at angle 0 */
 export declare const star: (numVerticesPerRadius: number, radius?: number, innerRadius?: number, rounding?: CornerRounding, innerRounding?: CornerRounding, perVertexRounding?: CornerRounding[], centerX?: number, centerY?: number) => RoundedPolygon;
-/** A rectangle centred on (centerX, centerY), its first vertex at the bottom right (graphics-shapes rectangle) */
 export declare const rectangle: (width?: number, height?: number, rounding?: CornerRounding, perVertexRounding?: CornerRounding[], centerX?: number, centerY?: number) => RoundedPolygon;
 export declare const transformPolygon: (polygon: RoundedPolygon, f: PointTransformer) => RoundedPolygon;
-/** Rotation about the origin, in degrees, positive clockwise on a y-down canvas */
 export declare const rotatePolygon: (polygon: RoundedPolygon, degrees: number) => RoundedPolygon;
 export declare const scalePolygon: (polygon: RoundedPolygon, sx: number, sy?: number) => RoundedPolygon;
-/** Bounding box [left, top, right, bottom] from the hull of anchors and controls */
-export declare const polygonBounds: (polygon: RoundedPolygon) => [number, number, number, number];
-/** The farthest any anchor or curve midpoint gets from the centre */
+export declare const polygonBounds: (polygon: RoundedPolygon) => [
+    number,
+    number,
+    number,
+    number
+];
 export declare const polygonMaxRadius: (polygon: RoundedPolygon) => number;
-/** Fits the shape into the unit square, centred, keeping its aspect ratio */
 export declare const normalizePolygon: (polygon: RoundedPolygon) => RoundedPolygon;

package/dist/core/state/emitter.d.ts

@@ -1,46 +1,10 @@
-/**
- * @module core/state
- */
-/**
- * An event handler. A handler that declares its payload type is accepted as
- * one, and a handler that doesn't gets `unknown` to narrow. It was
- * `(...args: never[]) => void`, which inferred every such payload as `never`
- * The method-signature form keeps parameter bivariance, which is
- * what lets a typed handler through.
- */
 export type EventCallback = {
     handler(...args: unknown[]): void;
 }["handler"];
-/**
- * Interface for the event emitter
- */
 export interface Emitter {
-    /**
-     * Subscribe to an event
-     * @param event - Event name
-     * @param callback - Event handler
-     * @returns Unsubscribe function
-     */
     on(event: string, callback: EventCallback): () => void;
-    /**
-     * Unsubscribe from an event
-     * @param event - Event name
-     * @param callback - Event handler to remove
-     */
     off(event: string, callback: EventCallback): void;
-    /**
-     * Emit an event
-     * @param event - Event name
-     * @param args - Event arguments
-     */
     emit(event: string, ...args: unknown[]): void;
-    /**
-     * Clear all event listeners
-     */
     clear(): void;
 }
-/**
- * Creates an event emitter with subscription management
- * @returns Event emitter interface
- */
 export declare const createEmitter: () => Emitter;

package/dist/core/state/events.d.ts

@@ -1,37 +1,8 @@
 import type { EventCallback } from "./emitter.js";
-/**
- * Event manager interface for handling component events
- */
 export interface EventManagerState {
-    /**
-     * Adds an event listener
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns EventManagerState instance for chaining
-     */
     on: (event: string, handler: EventCallback) => EventManagerState;
-    /**
-     * Removes an event listener
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns EventManagerState instance for chaining
-     */
     off: (event: string, handler: EventCallback) => EventManagerState;
-    /**
-     * Removes all event listeners and cleans up
-     */
     destroy: () => void;
-    /**
-     * Gets all active handlers
-     * @returns Map of event names to handlers
-     */
     getHandlers: () => Map<EventCallback, string>;
 }
-/**
- * Creates an event manager for a component
- * Simple event handling mechanism for components
- *
- * @param element - Component's DOM element
- * @returns Event manager interface
- */
 export declare const createEventManager: (element: HTMLElement) => EventManagerState;

package/dist/core/state/store.d.ts

@@ -1,90 +1,20 @@
-/**
- * State store options
- */
 export interface StoreOptions<T> {
-    /**
-     * Middleware functions that process state changes
-     */
     middleware?: Array<(newState: T, oldState: T) => T>;
 }
-/**
- * State selector function type
- */
 export type Selector<T, R> = (state: T) => R;
-/**
- * State computation function type for derived state
- */
 export type Computation<T, R> = (state: T) => R;
-/**
- * State updater function type
- */
 export type Updater<T> = (state: T) => T;
-/**
- * What derive() returns: call it to remove the derived value, or read the
- * value, typed, through get(). getState() carries derived values at runtime
- * but its type is the base state, so this is the typed way to read one.
- */
 export type DerivedState<R> = (() => void) & {
     get: () => R;
 };
-/**
- * State store interface
- */
 export interface Store<T> {
-    /**
-     * Gets current state including derived values
-     * @returns Current state
-     */
     getState: <D extends object = Record<never, never>>() => T & D;
-    /**
-     * Updates state
-     * @param update - State update object or updater function
-     */
     setState: (update: Partial<T> | Updater<T>) => void;
-    /**
-     * Subscribes to state changes
-     * @param listener - Change listener
-     * @returns Unsubscribe function
-     */
     subscribe: (listener: (state: T, oldState: T) => void) => () => void;
-    /**
-     * Creates a derived state value
-     * @param key - Derived state key
-     * @param computation - Function to compute derived value
-     * @returns Function to remove derived state
-     */
     derive: <K extends string, R>(key: K, computation: Computation<T, R>) => DerivedState<R>;
-    /**
-     * Selects a specific slice of state
-     * @param selector - State selector function
-     * @returns Selected state
-     */
     select: <R>(selector: Selector<T, R>) => R;
-    /**
-     * Resets state to initial values
-     */
     reset: () => void;
 }
-/**
- * Creates a state store with support for derived state and middleware
- *
- * @param initialState - Initial state object
- * @param options - Store options
- * @returns State store interface
- */
 export declare const createStore: <T extends object>(initialState?: T, options?: StoreOptions<T>) => Store<T>;
-/**
- * Example middleware that logs state changes
- *
- * @param newState - New state after change
- * @param oldState - Previous state before change
- * @returns Processed state (unchanged in this middleware)
- */
 export declare const loggingMiddleware: <T extends object>(newState: T, oldState: T) => T;
-/**
- * Creates a derived state selector for filtering objects
- *
- * @param predicate - Filter predicate function
- * @returns Computation function for derived state
- */
 export declare const deriveFiltered: <T>(predicate: (value: T, key: string) => boolean) => (state: Record<string, T>) => Record<string, T>;

package/dist/core/theme/index.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module core/theme
- */
 export { schemeToTokens, THEME_ROLES } from "./tokens.js";
 export { cornerToken } from "./shape.js";
 export type { ShapeStep } from "./shape.js";

package/dist/core/theme/shape.d.ts

@@ -1,9 +1,2 @@
-/**
- * The shape scale's corner tokens, for a radius a component writes from
- * script: as the stylesheets read it, the token with the compiled
- * value as its fallback, so a theme's corners reach inline styles too.
- */
-/** A step of M3's shape scale, as `$shape` in src/styles/abstract/_variables.scss names it. */
 export type ShapeStep = "none" | "extra-small" | "small" | "medium" | "large" | "large-increased" | "extra-large" | "extra-large-increased" | "extra-extra-large";
-/** `var(--mtrl-sys-shape-corner-small, 8px)`: a step's token, its px the fallback. */
 export declare const cornerToken: (step: ShapeStep, px: number, prefix?: string) => string;