@mono-lit/helper 0.0.2 → 0.0.3

package/dist/src/composables/popup-portal.d.ts

@@ -1,88 +1,89 @@
-import { ReactiveController, ReactiveControllerHost } from 'lit';
-import { PopupLayer } from './popup-stack';
+import { PopupLayer } from "./popup-stack.js";
+import { ReactiveController, ReactiveControllerHost } from "lit";
+//#region src/composables/popup-portal.d.ts
 type PopupHost = ReactiveControllerHost & HTMLElement & {
-    readonly renderRoot: HTMLElement | DocumentFragment;
+  readonly renderRoot: HTMLElement | DocumentFragment;
 };
 export type PopupSide = 'top' | 'bottom' | 'left' | 'right';
 export type PopupAlign = 'start' | 'center' | 'end';
 export interface PopupPortalOptions {
-    /** Locate the panel element (searched in the host's render root). */
-    getPanel: () => HTMLElement | null;
-    /** Element the panel is anchored to (the trigger / field). */
-    getAnchor: () => HTMLElement | null;
-    /**
-     * Element whose class list AND `mono-*` attributes are mirrored onto the portal
-     * so the relocated panel keeps its theme CSS variables and state-dependent
-     * styles — the legacy `.mono-select.open .mono-select-dropdown` rule and the
-     * Basecoat-ported `[mono-select][mono-open] > [mono-dropdown]` one alike, with
-     * the `--_mono-<c>-*` resolvers declared on `[mono-<c>]` re-resolving on the
-     * portal. Usually the host or its inner wrapper `<div>`.
-     */
-    getStyleScope: () => HTMLElement | null;
-    /**
-     * The component's PUBLIC custom-property names, so a relocated panel keeps
-     * overrides an ancestor of the host set.
-     *
-     * Class and attribute mirroring is not enough for these: a custom property is
-     * inherited, and a portaled panel is a child of `<body>`, so
-     * `--mono-dropdown-radius` set on a wrapper around the host simply is not in
-     * its inheritance chain any more. `getComputedStyle` cannot enumerate custom
-     * properties (Chromium lists none of them), so the component has to name the
-     * ones it reads; each is resolved on the scope and copied onto the portal when
-     * it differs from what the portal already resolves.
-     */
-    styleVars?: () => readonly string[];
-    /** Whether the popup is currently open. */
-    isOpen: () => boolean;
-    side?: () => PopupSide;
-    align?: () => PopupAlign;
-    offset?: () => number;
-    flip?: () => boolean;
-    shift?: () => boolean;
-    /** Panel width tracks the anchor's width (select / tag-input full-width drop). */
-    /**
-     * Stretch the panel to the anchor's width on every reposition.
-     *
-     * A GETTER as well as a plain boolean, because a component may want it to follow a prop: a
-     * consumer that sets an explicit panel width needs this off, or the write below overwrites it
-     * on the next open / scroll / resize.
-     */
-    matchWidth?: boolean | (() => boolean);
-    /**
-     * Publish the room available on the resolved side as `--mono-popup-avail-h`
-     * (main axis) / `--mono-popup-avail-w` (cross axis) on the panel, so its CSS
-     * can shrink instead of spilling off-screen. See {@link applyPopupPlacement}.
-     */
-    constrainSize?: () => boolean;
-    /** Notified when the resolved side changes after flipping. */
-    onSideResolved?: (side: PopupSide) => void;
+  /** Locate the panel element (searched in the host's render root). */
+  getPanel: () => HTMLElement | null;
+  /** Element the panel is anchored to (the trigger / field). */
+  getAnchor: () => HTMLElement | null;
+  /**
+   * Element whose class list AND `mono-*` attributes are mirrored onto the portal
+   * so the relocated panel keeps its theme CSS variables and state-dependent
+   * styles — the legacy `.mono-select.open .mono-select-dropdown` rule and the
+   * Basecoat-ported `[mono-select][mono-open] > [mono-dropdown]` one alike, with
+   * the `--_mono-<c>-*` resolvers declared on `[mono-<c>]` re-resolving on the
+   * portal. Usually the host or its inner wrapper `<div>`.
+   */
+  getStyleScope: () => HTMLElement | null;
+  /**
+   * The component's PUBLIC custom-property names, so a relocated panel keeps
+   * overrides an ancestor of the host set.
+   *
+   * Class and attribute mirroring is not enough for these: a custom property is
+   * inherited, and a portaled panel is a child of `<body>`, so
+   * `--mono-dropdown-radius` set on a wrapper around the host simply is not in
+   * its inheritance chain any more. `getComputedStyle` cannot enumerate custom
+   * properties (Chromium lists none of them), so the component has to name the
+   * ones it reads; each is resolved on the scope and copied onto the portal when
+   * it differs from what the portal already resolves.
+   */
+  styleVars?: () => readonly string[];
+  /** Whether the popup is currently open. */
+  isOpen: () => boolean;
+  side?: () => PopupSide;
+  align?: () => PopupAlign;
+  offset?: () => number;
+  flip?: () => boolean;
+  shift?: () => boolean;
+  /** Panel width tracks the anchor's width (select / tag-input full-width drop). */
+  /**
+   * Stretch the panel to the anchor's width on every reposition.
+   *
+   * A GETTER as well as a plain boolean, because a component may want it to follow a prop: a
+   * consumer that sets an explicit panel width needs this off, or the write below overwrites it
+   * on the next open / scroll / resize.
+   */
+  matchWidth?: boolean | (() => boolean);
+  /**
+   * Publish the room available on the resolved side as `--mono-popup-avail-h`
+   * (main axis) / `--mono-popup-avail-w` (cross axis) on the panel, so its CSS
+   * can shrink instead of spilling off-screen. See {@link applyPopupPlacement}.
+   */
+  constrainSize?: () => boolean;
+  /** Notified when the resolved side changes after flipping. */
+  onSideResolved?: (side: PopupSide) => void;
 }
 export interface PopupPlacementOptions {
-    side?: PopupSide;
-    align?: PopupAlign;
-    offset?: number;
-    flip?: boolean;
-    shift?: boolean;
-    /** Gap kept between the panel and the viewport edge. */
-    margin?: number;
-    /**
-     * The caller will clamp the panel to `availableMain` (see `constrainSize`), so
-     * anchor a flipped/`top`-side panel to the CLAMPED extent rather than its
-     * natural one. Off by default: an unconstrained panel keeps its natural size,
-     * and pretending otherwise would slide it over its own trigger.
-     */
-    constrain?: boolean;
+  side?: PopupSide;
+  align?: PopupAlign;
+  offset?: number;
+  flip?: boolean;
+  shift?: boolean;
+  /** Gap kept between the panel and the viewport edge. */
+  margin?: number;
+  /**
+   * The caller will clamp the panel to `availableMain` (see `constrainSize`), so
+   * anchor a flipped/`top`-side panel to the CLAMPED extent rather than its
+   * natural one. Off by default: an unconstrained panel keeps its natural size,
+   * and pretending otherwise would slide it over its own trigger.
+   */
+  constrain?: boolean;
 }
 export interface PopupPlacement {
-    top: number;
-    left: number;
-    /** The side actually used (may differ from the preferred one after flipping). */
-    side: PopupSide;
-    /**
-     * Room between the anchor and the viewport edge along the panel's main axis
-     * on the resolved side — height for top/bottom, width for left/right.
-     */
-    availableMain: number;
+  top: number;
+  left: number;
+  /** The side actually used (may differ from the preferred one after flipping). */
+  side: PopupSide;
+  /**
+   * Room between the anchor and the viewport edge along the panel's main axis
+   * on the resolved side — height for top/bottom, width for left/right.
+   */
+  availableMain: number;
 }
 /**
  * True when an event's composed path passes through any of `roots` — directly,
@@ -124,103 +125,104 @@ export declare function computePopupPlacement(anchor: HTMLElement, panel: HTMLEl
  */
 export declare function applyPopupPlacement(panel: HTMLElement, placement: PopupPlacement, constrain?: boolean): void;
 export declare class PopupPortalController implements ReactiveController, PopupLayer {
-    private readonly host;
-    private readonly opts;
-    private _portal;
-    /** Cached panel reference (it leaves the render root once adopted). */
-    private _panel;
-    private _adopted;
-    private _registered;
-    private _resolvedSide;
-    /** Keeps the portal's mirrored class current even when the host applies its
-     *  state classes imperatively in `updated()` (which runs *after* the
-     *  controller's `hostUpdated`). */
-    private _classObserver;
-    /** Whether the viewport listeners are currently attached (open-only, see
-     *  `_bindViewport`). Keeps the add/remove pair balanced across the several
-     *  paths that can open or close a popup. */
-    private _viewportBound;
-    /** Pending reposition frame, so a scroll burst costs one layout, not one per event. */
-    private _viewportFrame;
-    constructor(host: PopupHost, opts: PopupPortalOptions);
-    hostConnected(): void;
-    hostDisconnected(): void;
-    hostUpdated(): void;
-    /**
-     * Only relocate to `<body>` when the host renders into light DOM
-     * (`renderRoot === host`). Shadow hosts keep the panel in their shadow root.
-     */
-    private get _canPortal();
-    private _ensurePortal;
-    /** Move the panel into the body portal on first open; keep it there after. */
-    private _adopt;
-    /** Mirror the style-scope element's classes and `mono-*` attributes onto the portal. */
-    private _syncPortalClass;
-    /**
-     * Carry the component's public custom properties across the portal (see
-     * `styleVars`). Only values that DIFFER from the portal's own resolution are
-     * written, so a theme-level token stays inherited and only a real override
-     * (an ancestor of the host, or an inline style on it) is copied.
-     */
-    private _syncPortalVars;
-    /**
-     * Watch the style-scope's `class` attribute so the portal stays in sync even
-     * when the host toggles state classes (e.g. `open`) imperatively in
-     * `updated()`, which runs after the controller's `hostUpdated`.
-     */
-    private _observeStyleScope;
-    private _enterStack;
-    private _leaveStack;
-    /** PopupLayer hook — write the chained z onto the portal (root context). */
-    setStackZ(z: number): void;
-    /** Where panel-internal elements live now (portal while adopted, else host). */
-    get panelRoot(): ParentNode;
-    /**
-     * True when an event's composed path passes through this popup — its own
-     * portaled panel, OR any popup that was opened from inside it.
-     *
-     * The second half is what keeps a nested popup from dismissing its parent:
-     * a header filter opened from a `<mono-table-th>` in a dropdown-table's
-     * panel, a select's option list inside a modal — each lives in a portal of
-     * its own on `<body>`, so a click in it is nowhere near the parent in the
-     * DOM. It IS inside by ownership, and that is what every outside-click test
-     * in the library asks this method.
-     */
-    containsInPath(path: EventTarget[]): boolean;
-    /**
-     * True when the path passes through a popup opened from INSIDE this one
-     * (at any depth) — not this popup's own panel.
-     *
-     * Walks each portal in the path back to its owner and asks whether that
-     * owner lives in this host or this panel; an owner that is itself inside
-     * another popup climbs to that popup's owner, so a select inside a filter
-     * inside a dropdown-table resolves all the way up. Composed-tree
-     * containment throughout: the owner may sit behind a slot or a shadow root.
-     */
-    ownsNestedInPath(path: EventTarget[]): boolean;
-    /**
-     * Listen for viewport movement — but ONLY while this popup is open.
-     *
-     * These used to be bound in `hostConnected`, which meant one capture-phase
-     * `scroll` listener on `window` per popup-capable element on the page, open or
-     * not: every select, every table header filter, every search box — and one per
-     * ROW on a grid that puts a `mono-button-dropdown` in each. `_onViewport` bails
-     * when closed, so the handler was free; the *dispatch* was not, and a
-     * non-passive capture listener on `window` also disqualifies the whole page's
-     * scrolling from running off the compositor thread.
-     *
-     * `passive` because nothing here calls `preventDefault`.
-     */
-    private _bindViewport;
-    private _unbindViewport;
-    /**
-     * Coalesced to one frame: `reposition()` writes then reads
-     * (`getBoundingClientRect` on anchor and panel) and walks the ancestors with
-     * `getComputedStyle`, i.e. it forces a synchronous layout. Running that once per
-     * scroll event rather than once per frame is what made scrolling a modal body
-     * with an open dropdown stutter.
-     */
-    private _onViewport;
-    reposition(): void;
+  private readonly host;
+  private readonly opts;
+  private _portal;
+  /** Cached panel reference (it leaves the render root once adopted). */
+  private _panel;
+  private _adopted;
+  private _registered;
+  private _resolvedSide;
+  /** Keeps the portal's mirrored class current even when the host applies its
+   *  state classes imperatively in `updated()` (which runs *after* the
+   *  controller's `hostUpdated`). */
+  private _classObserver;
+  /** Whether the viewport listeners are currently attached (open-only, see
+   *  `_bindViewport`). Keeps the add/remove pair balanced across the several
+   *  paths that can open or close a popup. */
+  private _viewportBound;
+  /** Pending reposition frame, so a scroll burst costs one layout, not one per event. */
+  private _viewportFrame;
+  constructor(host: PopupHost, opts: PopupPortalOptions);
+  hostConnected(): void;
+  hostDisconnected(): void;
+  hostUpdated(): void;
+  /**
+   * Only relocate to `<body>` when the host renders into light DOM
+   * (`renderRoot === host`). Shadow hosts keep the panel in their shadow root.
+   */
+  private get _canPortal();
+  private _ensurePortal;
+  /** Move the panel into the body portal on first open; keep it there after. */
+  private _adopt;
+  /** Mirror the style-scope element's classes and `mono-*` attributes onto the portal. */
+  private _syncPortalClass;
+  /**
+   * Carry the component's public custom properties across the portal (see
+   * `styleVars`). Only values that DIFFER from the portal's own resolution are
+   * written, so a theme-level token stays inherited and only a real override
+   * (an ancestor of the host, or an inline style on it) is copied.
+   */
+  private _syncPortalVars;
+  /**
+   * Watch the style-scope's `class` attribute so the portal stays in sync even
+   * when the host toggles state classes (e.g. `open`) imperatively in
+   * `updated()`, which runs after the controller's `hostUpdated`.
+   */
+  private _observeStyleScope;
+  private _enterStack;
+  private _leaveStack;
+  /** PopupLayer hook — write the chained z onto the portal (root context). */
+  setStackZ(z: number): void;
+  /** Where panel-internal elements live now (portal while adopted, else host). */
+  get panelRoot(): ParentNode;
+  /**
+   * True when an event's composed path passes through this popup — its own
+   * portaled panel, OR any popup that was opened from inside it.
+   *
+   * The second half is what keeps a nested popup from dismissing its parent:
+   * a header filter opened from a `<mono-table-th>` in a dropdown-table's
+   * panel, a select's option list inside a modal — each lives in a portal of
+   * its own on `<body>`, so a click in it is nowhere near the parent in the
+   * DOM. It IS inside by ownership, and that is what every outside-click test
+   * in the library asks this method.
+   */
+  containsInPath(path: EventTarget[]): boolean;
+  /**
+   * True when the path passes through a popup opened from INSIDE this one
+   * (at any depth) — not this popup's own panel.
+   *
+   * Walks each portal in the path back to its owner and asks whether that
+   * owner lives in this host or this panel; an owner that is itself inside
+   * another popup climbs to that popup's owner, so a select inside a filter
+   * inside a dropdown-table resolves all the way up. Composed-tree
+   * containment throughout: the owner may sit behind a slot or a shadow root.
+   */
+  ownsNestedInPath(path: EventTarget[]): boolean;
+  /**
+   * Listen for viewport movement — but ONLY while this popup is open.
+   *
+   * These used to be bound in `hostConnected`, which meant one capture-phase
+   * `scroll` listener on `window` per popup-capable element on the page, open or
+   * not: every select, every table header filter, every search box — and one per
+   * ROW on a grid that puts a `mono-button-dropdown` in each. `_onViewport` bails
+   * when closed, so the handler was free; the *dispatch* was not, and a
+   * non-passive capture listener on `window` also disqualifies the whole page's
+   * scrolling from running off the compositor thread.
+   *
+   * `passive` because nothing here calls `preventDefault`.
+   */
+  private _bindViewport;
+  private _unbindViewport;
+  /**
+   * Coalesced to one frame: `reposition()` writes then reads
+   * (`getBoundingClientRect` on anchor and panel) and walks the ancestors with
+   * `getComputedStyle`, i.e. it forces a synchronous layout. Running that once per
+   * scroll event rather than once per frame is what made scrolling a modal body
+   * with an open dropdown stutter.
+   */
+  private _onViewport;
+  reposition(): void;
 }
-export {};
+//#endregion
+export {};

package/dist/src/composables/popup-stack.d.ts

@@ -1,42 +1,43 @@
+//#region src/composables/popup-stack.d.ts
 /** First layer's z-index. Each subsequent open layer sits one STEP higher. */
 export declare const POPUP_Z_BASE = 1000;
 /** Gap between adjacent layers — leaves room for overlay(z) + panel(z+1) pairs. */
 export declare const POPUP_Z_STEP = 10;
 export interface PopupLayer {
-    /**
-     * Apply the z-index for this layer's current slot in the stack.
-     * `isTopBackdrop` is true when no other *backdrop-bearing* layer (modal /
-     * drawer) sits above this one. Backdrop layers use it to dim their own
-     * overlay only when another overlay already covers them; lightweight popups
-     * (which render no backdrop) ignore it.
-     */
-    setStackZ(z: number, isTopBackdrop: boolean): void;
-    /** True while this layer wants the document body scroll locked (modal/drawer). */
-    readonly lockBodyScroll?: boolean;
-    /**
-     * True when this layer renders its own dim backdrop / overlay (modal, drawer).
-     * Only these layers participate in the `isTopBackdrop` computation, so opening
-     * a backdrop-less popup (dropdown/select/…) above a modal never hides the
-     * modal's backdrop.
-     */
-    readonly hasBackdrop?: boolean;
-    /**
-     * Called when Escape is pressed and this layer is the topmost one. Layers that
-     * own their own Escape handling (dropdown/select/…) simply don't implement it,
-     * in which case Escape is a no-op at the stack level.
-     */
-    onStackEscape?(event: KeyboardEvent): void;
-    /**
-     * The level this layer actually paints at when it refuses the slot it is
-     * handed — modal / drawer's `z-index` prop. `undefined` (the default) means
-     * "use the slot", which is every other layer.
-     *
-     * The chain RESUMES from this value rather than from the slot index, because
-     * layers opened above a pinned one have to clear it. Without that, a dialog
-     * pinned to 10_000_000 leaves the select opened inside it at 1010 — painted
-     * underneath the very dialog it belongs to.
-     */
-    readonly pinnedZ?: number;
+  /**
+   * Apply the z-index for this layer's current slot in the stack.
+   * `isTopBackdrop` is true when no other *backdrop-bearing* layer (modal /
+   * drawer) sits above this one. Backdrop layers use it to dim their own
+   * overlay only when another overlay already covers them; lightweight popups
+   * (which render no backdrop) ignore it.
+   */
+  setStackZ(z: number, isTopBackdrop: boolean): void;
+  /** True while this layer wants the document body scroll locked (modal/drawer). */
+  readonly lockBodyScroll?: boolean;
+  /**
+   * True when this layer renders its own dim backdrop / overlay (modal, drawer).
+   * Only these layers participate in the `isTopBackdrop` computation, so opening
+   * a backdrop-less popup (dropdown/select/…) above a modal never hides the
+   * modal's backdrop.
+   */
+  readonly hasBackdrop?: boolean;
+  /**
+   * Called when Escape is pressed and this layer is the topmost one. Layers that
+   * own their own Escape handling (dropdown/select/…) simply don't implement it,
+   * in which case Escape is a no-op at the stack level.
+   */
+  onStackEscape?(event: KeyboardEvent): void;
+  /**
+   * The level this layer actually paints at when it refuses the slot it is
+   * handed — modal / drawer's `z-index` prop. `undefined` (the default) means
+   * "use the slot", which is every other layer.
+   *
+   * The chain RESUMES from this value rather than from the slot index, because
+   * layers opened above a pinned one have to clear it. Without that, a dialog
+   * pinned to 10_000_000 leaves the select opened inside it at 1010 — painted
+   * underneath the very dialog it belongs to.
+   */
+  readonly pinnedZ?: number;
 }
 /** Add a layer to the top of the stack (call on open). */
 export declare function registerPopupLayer(layer: PopupLayer): void;
@@ -68,3 +69,4 @@ export declare function setExternalScrollLock(owner: object, wanted: boolean): v
  * own type — filter the returned list by `instanceof`.
  */
 export declare function getOpenPopupLayers(): readonly PopupLayer[];
+//#endregion

package/dist/src/composables/rate-limit.d.ts

@@ -1,19 +1,20 @@
-import { ComplexAttributeConverter } from 'lit';
+import { ComplexAttributeConverter } from "lit";
+//#region src/composables/rate-limit.d.ts
 /** `p-throttle` options we expose. Mirrors the upstream option names. */
 export interface ThrottleConfig {
-    /** Maximum number of calls within `interval`. Default 1. */
-    limit?: number;
-    /** Timespan for `limit`, in ms. Default 1000. */
-    interval?: number;
-    /** Throttle each call individually instead of using a window. Default false. */
-    strict?: boolean;
+  /** Maximum number of calls within `interval`. Default 1. */
+  limit?: number;
+  /** Timespan for `limit`, in ms. Default 1000. */
+  interval?: number;
+  /** Throttle each call individually instead of using a window. Default false. */
+  strict?: boolean;
 }
 /** `p-debounce` options we expose. Mirrors the upstream option names. */
 export interface DebounceConfig {
-    /** Milliseconds to wait after the last call. Default 300. */
-    wait?: number;
-    /** Run on the leading edge instead of the trailing edge. Default false. */
-    before?: boolean;
+  /** Milliseconds to wait after the last call. Default 300. */
+  wait?: number;
+  /** Run on the leading edge instead of the trailing edge. Default false. */
+  before?: boolean;
 }
 /**
  * What a rate-limit prop accepts: the config object, a bare number shorthand, a
@@ -60,28 +61,28 @@ export declare const rateLimitConverter: ComplexAttributeConverter<unknown>;
  */
 export type RateLimitPhase = 'pending' | 'running' | 'idle';
 export interface RateLimiter {
-    /** Put a call through the limiter. Never rejects on cancellation. */
-    call(...args: unknown[]): Promise<unknown>;
-    /** Drop everything pending. The wrapper is rebuilt on the next `call()`. */
-    cancel(): void;
-    /** Cancel and release the wrapper (use on disconnect). */
-    dispose(): void;
-    /** Calls accepted but not yet settled (waiting *or* executing). */
-    readonly pending: number;
-    /** Calls currently executing `run`. */
-    readonly running: number;
-    /** Derived phase, for reporting. */
-    readonly phase: RateLimitPhase;
-    /** Calls waiting in the throttle queue (always 0 for a debouncer). */
-    readonly queueSize: number;
+  /** Put a call through the limiter. Never rejects on cancellation. */
+  call(...args: unknown[]): Promise<unknown>;
+  /** Drop everything pending. The wrapper is rebuilt on the next `call()`. */
+  cancel(): void;
+  /** Cancel and release the wrapper (use on disconnect). */
+  dispose(): void;
+  /** Calls accepted but not yet settled (waiting *or* executing). */
+  readonly pending: number;
+  /** Calls currently executing `run`. */
+  readonly running: number;
+  /** Derived phase, for reporting. */
+  readonly phase: RateLimitPhase;
+  /** Calls waiting in the throttle queue (always 0 for a debouncer). */
+  readonly queueSize: number;
 }
 export interface CreateRateLimiterOptions {
-    kind: 'throttle' | 'debounce';
-    config: ResolvedThrottleConfig | ResolvedDebounceConfig;
-    /** The work to rate-limit. Its promise defines the `running` phase. */
-    run: (...args: unknown[]) => unknown | Promise<unknown>;
-    /** Called whenever `pending` / `running` change, so the host can re-render. */
-    onChange?: () => void;
+  kind: 'throttle' | 'debounce';
+  config: ResolvedThrottleConfig | ResolvedDebounceConfig;
+  /** The work to rate-limit. Its promise defines the `running` phase. */
+  run: (...args: unknown[]) => unknown | Promise<unknown>;
+  /** Called whenever `pending` / `running` change, so the host can re-render. */
+  onChange?: () => void;
 }
 /**
  * Build a limiter around `run`.
@@ -106,3 +107,4 @@ export interface CreateRateLimiterOptions {
  * it with a fresh controller.
  */
 export declare function createRateLimiter(options: CreateRateLimiterOptions): RateLimiter;
+//#endregion

package/dist/src/composables/reactive.d.ts

@@ -1,3 +1,4 @@
+//#region src/composables/reactive.d.ts
 /**
  * Undoing framework reactivity, structurally.
  *
@@ -34,7 +35,7 @@ export declare function unwrapReactive<T = unknown>(value: T): T;
  * what makes the CURRENT reactive value the one that lands in the request.
  */
 export type MaybeReactive<T> = T | (() => T) | {
-    value: T;
+  value: T;
 };
 /**
  * Read a {@link MaybeReactive} option: call a getter, unwrap a ref/computed or a
@@ -51,3 +52,4 @@ export declare function resolveMaybeReactive<T>(option: MaybeReactive<T> | undef
  * into nested objects, which would rewrite data the consumer owns.
  */
 export declare function unwrapReactiveDeep<T = unknown>(value: T): T;
+//#endregion

package/dist/src/composables/shadow-css.d.ts

@@ -1,19 +1,20 @@
-import { LitElement } from 'lit';
+import { LitElement } from "lit";
+//#region src/composables/shadow-css.d.ts
 type Constructor<T = object> = new (...args: any[]) => T;
 export interface ToShadowCssOptions {
-    /**
-     * Element-selector tag to rewrite to `:host` (e.g. `'mono-nav'`). Handles
-     * `tag { … }`, `tag[attr] { … }` and `tag,` — but NOT `.tag` or `tag-suffix`.
-     */
-    host?: string;
-    /**
-     * Prepend `:host { display: <value> }`. Use when the component has no element
-     * selector to rewrite (its state classes live on an inner root) but the host
-     * still needs a display value (e.g. dropdown → `'inline-block'`).
-     */
-    hostDisplay?: string;
-    /** Shadow-only CSS appended verbatim (e.g. `[data-empty] { display: none }`). */
-    append?: string;
+  /**
+   * Element-selector tag to rewrite to `:host` (e.g. `'mono-nav'`). Handles
+   * `tag { … }`, `tag[attr] { … }` and `tag,` — but NOT `.tag` or `tag-suffix`.
+   */
+  host?: string;
+  /**
+   * Prepend `:host { display: <value> }`. Use when the component has no element
+   * selector to rewrite (its state classes live on an inner root) but the host
+   * still needs a display value (e.g. dropdown → `'inline-block'`).
+   */
+  hostDisplay?: string;
+  /** Shadow-only CSS appended verbatim (e.g. `[data-empty] { display: none }`). */
+  append?: string;
 }
 export declare function toShadowCss(css: string, opts?: ToShadowCssOptions): string;
 /**
@@ -39,4 +40,5 @@ export declare function adoptUtilityStyles(root: ShadowRoot | null | undefined):
  * snap in on hydration). Apply as `extends withShadowUtilityStyles(XCore(LitElement))`.
  */
 export declare function withShadowUtilityStyles<T extends Constructor<LitElement>>(superClass: T): T;
-export {};
+//#endregion
+export {};

package/dist/src/composables/visibility.d.ts

@@ -1,3 +1,4 @@
+//#region src/composables/visibility.d.ts
 /**
  * Shared `visible` / `visibleType` support for the controls `monoForm` drives.
  *
@@ -16,10 +17,10 @@
 export type MonoVisibleType = 'invisible' | 'none';
 /** The two visibility props shared by every form-driven control. */
 export interface VisibilityProps {
-    /** Whether the control is shown. Defaults to `true`. */
-    visible?: boolean;
-    /** How it hides when `visible` is `false`. Defaults to `'none'`. */
-    visibleType?: MonoVisibleType;
+  /** Whether the control is shown. Defaults to `true`. */
+  visible?: boolean;
+  /** How it hides when `visible` is `false`. Defaults to `'none'`. */
+  visibleType?: MonoVisibleType;
 }
 /**
  * Write (or clear) the hide style on a HOST element.
@@ -34,3 +35,4 @@ export interface VisibilityProps {
  * host survives a hide/show round trip.
  */
 export declare function applyVisibility(host: HTMLElement, visible: boolean, type: MonoVisibleType): void;
+//#endregion