material 3.2.5 → 3.2.7

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

@@ -1,69 +1,17 @@
-/**
- * @module core/dom
- * @description DOM manipulation utilities
- */
-/**
- * Event manager interface for handling DOM events
- */
 export interface EventManager {
-    /**
-     * Add an event listener with options
-     * @param event - Event name
-     * @param handler - Event handler
-     * @param options - addEventListener options
-     * @returns EventManager instance for chaining
-     */
     on: <T extends Event>(event: string, handler: (e: T) => void, options?: AddEventListenerOptions) => EventManager;
-    /**
-     * Remove an event listener
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns EventManager instance for chaining
-     */
     off: <T extends Event>(event: string, handler: (e: T) => void) => EventManager;
-    /**
-     * Temporarily disable all event listeners
-     * @returns EventManager instance for chaining
-     */
     pause: () => EventManager;
-    /**
-     * Re-enable all event listeners
-     * @returns EventManager instance for chaining
-     */
     resume: () => EventManager;
-    /**
-     * Remove all event listeners and clean up
-     */
     destroy: () => void;
-    /**
-     * Get all active handlers
-     * @returns Map of active handlers
-     */
     getHandlers: () => Map<string, HandlerInfo>;
-    /**
-     * Check if a specific handler exists
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns Whether handler exists
-     */
     hasHandler: <T extends Event>(event: string, handler: (e: T) => void) => boolean;
 }
-/**
- * Handler information
- */
 interface HandlerInfo {
     original: EventListener;
     enhanced: EventListener;
     event: string;
     options: AddEventListenerOptions;
 }
-/**
- * Creates an event manager to handle DOM events with enhanced functionality.
- * Provides a robust interface for managing event listeners with error handling,
- * cleanup, and lifecycle management.
- *
- * @param element - DOM element to attach events to
- * @returns Event manager interface
- */
 export declare const createEventManager: (element: HTMLElement) => EventManager;
 export {};

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

@@ -1,36 +1,4 @@
-/**
- * The focused element as seen from a node's own root: the shadow root it
- * lives in, or the document.
- *
- * `document.activeElement` stops at the shadow host when focus is inside a
- * shadow root, so a component rendered in one never finds its focused item
- * there. A detached node has neither root, and gets the document's.
- *
- * @param node - A node of the component, usually its element
- * @returns The active element of that node's root, or null
- */
 export declare const activeElementOf: (node: Node) => Element | null;
-/**
- * The element that really has focus, looked for through open shadow roots:
- * where focus goes back to after an overlay closes, when the overlay may sit
- * in another root than whatever opened it.
- *
- * @returns The innermost focused element, or null
- */
 export declare const deepActiveElement: () => Element | null;
-/**
- * The tab stops in a container, in the order Tab reaches them: through slots
- * to what is assigned to them and into shadow roots, which is where the
- * content of a web component sits. Slots are told by shape, as the roots are
- * above.
- */
 export declare const tabStops: (container: Element) => HTMLElement[];
-/**
- * Keeps Tab inside a modal: from its last tab stop to its first, and Shift+Tab
- * from the first (or the modal itself) to the last. Between them the browser
- * moves focus as it always does. For a keydown listener on the modal.
- *
- * @param container - The modal, which the keydown reached
- * @param event - The keydown
- */
 export declare const wrapTab: (container: HTMLElement, event: KeyboardEvent) => void;

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

@@ -1,34 +1,10 @@
-/** A value the browser's Trusted Types API accepts for innerHTML. */
 export interface TrustedHTMLLike {
     toString(): string;
 }
-/** Markup a component accepts: a string, or a TrustedHTML from a policy. */
 export type HTMLInput = string | TrustedHTMLLike;
 export interface HTMLPolicy {
-    /**
-     * Called with every markup string before it is written. Return the markup
-     * to write: a sanitized string, or a TrustedHTML from a Trusted Types
-     * policy. Values that are already TrustedHTML are not passed through it.
-     */
     sanitize: (html: string) => HTMLInput;
 }
-/**
- * Sets the policy every component's markup goes through, or clears it with
- * null.
- *
- * @example
- * // DOMPurify
- * configureHTML({ sanitize: (html) => DOMPurify.sanitize(html) });
- *
- * // Trusted Types: a policy the page's CSP allows
- * const trusted = window.trustedTypes.createPolicy('app', { createHTML: (html) => DOMPurify.sanitize(html) });
- * configureHTML({ sanitize: (html) => trusted.createHTML(html) });
- */
 export declare const configureHTML: (next: HTMLPolicy | null) => void;
-/** The policy in force, if any. */
 export declare const getHTMLPolicy: () => HTMLPolicy | null;
-/**
- * Writes markup into an element, through the policy when one is set.
- * An empty string empties the element without touching innerHTML.
- */
 export declare const setHTML: (element: Element, html: HTMLInput | null | undefined) => void;

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,33 +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. */
 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/navigation/destinations.js

@@ -1,6 +1,17 @@
 import { safeUrl } from "../utils/url.js";
 import { setHTML } from "../dom/html.js";
 import { activeElementOf } from "../dom/focus.js";
+const BADGE_MAX_CHARACTERS = 4;
+const formatBadgeText = (badge) => {
+    const text = String(badge);
+    if (text.length <= BADGE_MAX_CHARACTERS)
+        return text;
+    const numeric = Number(badge);
+    if (Number.isNaN(numeric))
+        return text.slice(0, BADGE_MAX_CHARACTERS);
+    return numeric >= 1000 ? "999+" : `${text.slice(0, BADGE_MAX_CHARACTERS - 1)}+`;
+};
+const isEmptyBadgeText = (text) => text === "" || text === "0";
 export const copyDestinations = (items, component) => {
     const ids = new Set();
     let selected = false;
@@ -15,7 +26,9 @@ export const copyDestinations = (items, component) => {
 };
 export const updateBadge = (item, element, cls) => {
     let badge = element.querySelector(`.${cls("__badge")}`);
-    const visible = item.badge !== undefined && item.badge !== false && item.badge !== "";
+    const dot = item.badge === true;
+    const text = dot ? "" : formatBadgeText(String(item.badge ?? ""));
+    const visible = dot || (item.badge !== undefined && item.badge !== null && item.badge !== false && !isEmptyBadgeText(text));
     if (!visible) {
         badge?.remove();
         element.classList.remove(cls("__item--badged"));
@@ -28,10 +41,10 @@ export const updateBadge = (item, element, cls) => {
         badge.setAttribute("aria-hidden", "true");
         element.querySelector(`.${cls("__content")}`).append(badge);
     }
-    badge.classList.toggle(cls("__badge--dot"), item.badge === true);
-    badge.textContent = item.badge === true ? "" : String(item.badge);
-    element.classList.toggle(cls("__item--badged"), item.badge !== true);
-    element.setAttribute("aria-label", `${item.label}, ${item.badgeLabel || (item.badge === true ? "New activity" : String(item.badge))}`);
+    badge.classList.toggle(cls("__badge--dot"), dot);
+    badge.textContent = text;
+    element.classList.toggle(cls("__item--badged"), !dot);
+    element.setAttribute("aria-label", `${item.label}, ${item.badgeLabel || (dot ? "New notification" : text)}`);
 };
 export const createDestination = (item, cls) => {
     const element = document.createElement(item.href ? "a" : "button");

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;