@sekiui/elements 0.1.3 → 0.1.5

package/dist/types/utils/context-bridge.d.ts

@@ -3,10 +3,25 @@
  *
  * Generalizes the "parent publishes state onto its host element + child
  * subscribes via closest()" pattern used by compound components (select,
- * toggle-group, combobox, ...). Each parent calls publishContext() from its
- * updateContextOnElement()-equivalent method; each child calls
- * subscribeToContextChange() once in componentDidLoad() and the returned
- * unsubscribe() in disconnectedCallback().
+ * toggle-group, combobox, dialog, popover, ...).
+ *
+ * Parent (provider) contract:
+ *   - call publishContext() from componentWillLoad(), so the context exists
+ *     before any child renders for the first time, and
+ *   - call it again on every state change, including changes that arrive as a
+ *     @Prop assignment (@Watch) rather than through a @Method or user input.
+ *
+ * Child (consumer) contract — use a ContextConsumer:
+ *   - call connect(this.el) from connectedCallback() (runs before the first
+ *     render, and again after the element is moved to a new parent), and
+ *   - call disconnect() from disconnectedCallback().
+ *   connect() invokes the callback once immediately, so a child that
+ *   upgrades after its parent already published still starts from the current
+ *   state; a child that upgrades before its parent (one-module-per-tag
+ *   loading, #314) hears the parent's first publish from componentWillLoad().
+ *
+ * subscribeToContextChange() is the older listener-only form (no immediate
+ * read, light-DOM closest() only); prefer ContextConsumer for new code.
  *
  * Extracted after the same bug (child freezes at mount-time state because
  * nothing told it the parent changed) was independently fixed three times
@@ -43,3 +58,52 @@ export declare function subscribeToContextChange(el: HTMLElement, parentSelector
     parent: HTMLElement | null;
     unsubscribe: () => void;
 };
+/**
+ * Nearest ancestor matching `selector`, continuing past shadow roots: when the
+ * element's own tree has no match, the search resumes from the shadow host.
+ * This lets a part rendered inside another component's shadow tree still find
+ * the provider that wraps that component.
+ */
+export declare function findContextProvider(el: Element, selector: string): HTMLElement | null;
+/**
+ * Child-side: tracks one provider (see findContextProvider) for a part.
+ *
+ *   private dialog = new ContextConsumer<DialogContext>('seki-dialog', '_dialogContext', () => this.sync());
+ *   connectedCallback() { this.dialog.connect(this.el); }
+ *   disconnectedCallback() { this.dialog.disconnect(); }
+ *
+ * connect() finds the provider, starts listening for its context-change
+ * notifications and calls `onChange` once right away, so the part starts from
+ * whatever is already published. `parent` and `context` are already set when
+ * that first call happens. Calling connect() from connectedCallback runs it
+ * before the first render and again after the part is moved to another
+ * provider.
+ *
+ * `onChange` gets no event payload by design (see SEKI_CONTEXT_CHANGE_EVENT):
+ * it reads the live `context`. Notifications bubbling up from a nested
+ * provider are ignored; only events dispatched by this part's own provider
+ * host (or retargeted to it from that host's shadow tree) count.
+ *
+ * Works whether or not the provider element has been upgraded yet: the
+ * listener sits on the element itself, so the provider's first
+ * publishContext() from componentWillLoad() reaches it.
+ */
+export declare class ContextConsumer<T> {
+    private readonly parentSelector;
+    private readonly propertyName;
+    private readonly onChange;
+    private provider;
+    constructor(parentSelector: string, propertyName: string, onChange: (context: T | null) => void);
+    /** The provider element found by the last connect(), or null. */
+    get parent(): HTMLElement | null;
+    /** The provider's current context, or null when there is none yet. */
+    get context(): T | null;
+    connect(host: HTMLElement): void;
+    disconnect(): void;
+    private handleEvent;
+}
+/**
+ * Read a context object a provider published with publishContext(). Returns
+ * null when there is no provider or it has not published yet.
+ */
+export declare function readContext<T>(parent: Element | null | undefined, propertyName: string): T | null;

package/dist/types/utils/dialog/focus-trap.d.ts

@@ -25,14 +25,3 @@ export declare function focusLast(container: HTMLElement): void;
  * Trap focus within a container during Tab key navigation.
  */
 export declare function trapFocus(container: HTMLElement, event: KeyboardEvent): void;
-/**
- * Lock body scroll when a modal opens. Safe to nest: the lock is only applied
- * on the first call and the original inline styles are restored on the last
- * matching unlock.
- */
-export declare function lockBodyScroll(): void;
-/**
- * Unlock body scroll when a modal closes. Only the final unlock restores the
- * original inline styles.
- */
-export declare function unlockBodyScroll(): void;

package/dist/types/utils/field-description.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Description and error association for `seki-field` (#358).
+ *
+ * ## Why this exists
+ *
+ * `seki-field` renders its description and error text in slots, but nothing
+ * told assistive technology that the control is described by them. An
+ * `aria-describedby` id on a SekiUI control's host cannot reach the real
+ * `<input>` / `<button>` inside the control's own shadow root, so (exactly as
+ * for labels, see `label-association.ts`) the wiring depends on the kind of
+ * control:
+ *
+ * - **Native controls** and SekiUI controls whose role lives on the host
+ *   (`seki-radio-group`, `seki-combobox`): the field and the control share a
+ *   tree, so `aria-describedby` / `aria-errormessage` id references resolve.
+ * - **Other SekiUI controls** (input, textarea, checkbox, switch, slider,
+ *   select, date-picker, input-otp) keep their focusable element in a shadow
+ *   root. They forward the plain-text `aria-description` and `aria-invalid`
+ *   attributes inward, so the description (and, when invalid, the error text)
+ *   is passed through as text.
+ * - **Several controls in one field**: the field host is the `role="group"`,
+ *   and it is the element that gets described.
+ *
+ * When the field is `invalid`, the control gets `aria-invalid="true"`, and the
+ * error is exposed both through `aria-errormessage` (where an id reference
+ * works) and by being appended to the description, since screen reader support
+ * for `aria-errormessage` is still uneven.
+ *
+ * Anything the author set explicitly is never overwritten. We only manage
+ * values we wrote ourselves, tracked with a marker attribute so they can be
+ * updated and cleaned up.
+ */
+export declare class FieldDescriptionBinding {
+    private readonly host;
+    private readonly isInvalid;
+    private target;
+    private observer?;
+    constructor(host: HTMLElement, isInvalid: () => boolean);
+    /** Direct children placed in (or, by tag, belonging to) the given part. */
+    private parts;
+    private controls;
+    private resolveTarget;
+    private text;
+    private ids;
+    /** (Re)apply the description. Call on load, on `invalid` change and on slot change. */
+    sync(): void;
+    /** Remove anything this binding wrote on the current target. */
+    release(): void;
+    /** Re-sync when the description, error or control changes after load. */
+    observe(): void;
+    disconnect(): void;
+}

package/dist/types/utils/label-association.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Label association for `seki-label` and `seki-field-label`.
+ *
+ * ## Why this exists
+ *
+ * Both labels render their text inside a shadow root. A native `<label for>`
+ * resolves its `for` id inside the tree the `<label>` lives in, so a `<label>`
+ * in our shadow root can never reach a control in the page's light DOM: clicks
+ * did nothing and the control had no accessible name (#329).
+ *
+ * The host element (`<seki-label>`) *does* live in the consumer's tree, so the
+ * wiring is done from the host in script, resolving the id against
+ * `host.getRootNode()` (the label's own root, which is where an author expects
+ * `for` to point, also when the label sits inside another component's shadow
+ * root together with its control).
+ *
+ * ## Behaviour
+ *
+ * - **Activation**: a click on the label forwards to the target the way a native
+ *   label would. Toggles (checkbox, switch, radio) are clicked, text-like
+ *   controls are focused. A click that originated on the control itself (the
+ *   wrapping form `<seki-label><seki-checkbox/> Text</seki-label>`) is ignored so
+ *   the control never toggles twice.
+ * - **Accessible name**: a shadow-DOM control hides its real focusable element
+ *   (`<button role="checkbox">`, `<input>`, ...) inside its own shadow root, and
+ *   an `aria-labelledby` id reference cannot cross a shadow boundary, so
+ *   pointing the host at the label would not name the inner element. SekiUI
+ *   controls all forward their `aria-label` attribute to that inner element, so
+ *   for them the label text is passed through as `aria-label`. For native
+ *   elements the reference does resolve, so we use `aria-labelledby` and the
+ *   name tracks the label's live content.
+ *   Anything the author set explicitly (`aria-label`, `aria-labelledby`) is
+ *   never overwritten; we only manage values we wrote ourselves, tracked with a
+ *   marker attribute so they can be updated and cleaned up.
+ *   `ElementInternals.ariaLabelledByElements` is deliberately not used: it is
+ *   unavailable in Firefox and older Safari, and cannot reach the inner element
+ *   of a shadow-DOM control either.
+ */
+export declare class LabelBinding {
+    private readonly host;
+    private readonly getFor;
+    private target;
+    private observer?;
+    constructor(host: HTMLElement, getFor: () => string | undefined);
+    /** Resolve the control this label is for, in the label's own root. */
+    resolveTarget(): HTMLElement | null;
+    /** Label text, without the text of a control nested inside the label. */
+    private labelText;
+    /** (Re)apply the accessible name. Call on load, `for` change and slot change. */
+    sync(): void;
+    /** Remove anything this binding wrote on the current target. */
+    release(): void;
+    /** Re-sync when the control is added after the label (async rendering). */
+    observe(): void;
+    disconnect(): void;
+    /** Forward a click on the label to its control, as a native label would. */
+    handleClick(event: Event): void;
+}

package/dist/types/utils/overlay.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Overlay layer stack, modal focus handling and body scroll lock, shared by
+ * every component that floats above the page and closes on Escape.
+ *
+ * ## Why this exists (#332)
+ *
+ * Each overlay used to listen for Escape on `window` by itself. All of those
+ * listeners run for the same key press, so a popover inside a dialog closed
+ * together with the dialog, and `stopPropagation()` in one handler did not stop
+ * the others. Sheet and drawer also rendered `aria-modal="true"` without any
+ * of the modal behaviour dialog had (focus moved in, Tab trapped, focus
+ * restored, page scroll locked).
+ *
+ * ## Model (matches Radix DismissableLayer / FocusScope)
+ *
+ * - Every open overlay is an {@link OverlayLayer} on one document-wide stack,
+ *   in the order the layers opened.
+ * - One pair of `window` keydown listeners handles Escape: the layer that was
+ *   on top when the key went down gets the key, nothing below it does. If an
+ *   element-level handler inside that layer already closed it (a combobox input
+ *   closing its list, a submenu calling `stopPropagation()`), the key is spent
+ *   and no other layer closes.
+ * - The topmost *modal* layer traps Tab inside its container. Modal layers
+ *   also move focus in when they open, return it to the element that had it
+ *   when they close, and lock body scroll. The lock is reference-counted, so a
+ *   dialog closing inside an open sheet leaves the page locked.
+ */
+/**
+ * Lock body scroll. Safe to nest: the lock is applied on the first call and
+ * the original inline styles come back on the matching last unlock.
+ */
+export declare function lockBodyScroll(): void;
+/** Release one lock taken with lockBodyScroll(). */
+export declare function unlockBodyScroll(): void;
+export interface OverlayLayerOptions {
+    /**
+     * Called when Escape is pressed while this layer is the topmost one. The
+     * handler decides whether to close (e.g. `closeOnEscape`); either way the
+     * key does not reach the layers below.
+     */
+    onEscape?: (event: KeyboardEvent) => void;
+    /**
+     * Modal layers trap Tab inside `container`, move focus into it on open,
+     * restore focus on close and lock body scroll. A function is read on every
+     * activation (dialog's `modal` prop can change).
+     */
+    modal?: boolean | (() => boolean);
+    /** The element focus is moved into and trapped in (modal layers). */
+    container?: () => HTMLElement | null | undefined;
+}
+/**
+ * One overlay's place on the layer stack.
+ *
+ *   private layer = new OverlayLayer({ onEscape: () => this.close() });
+ *   componentDidRender() { this.layer.setActive(this._isOpen); }
+ *   disconnectedCallback() { this.layer.setActive(false); }
+ *
+ * Modal content parts call `setActive()` from the code path that sees the
+ * open state change (so focus is captured before anything moves it) and
+ * `didRender()` from componentDidRender, which moves focus in once the
+ * container exists.
+ */
+export declare class OverlayLayer {
+    private readonly options;
+    private active;
+    private modalActive;
+    private returnFocusTo;
+    private focusPending;
+    constructor(options?: OverlayLayerOptions);
+    get isActive(): boolean;
+    /** Whether this layer is open and modal (traps focus, locks scroll). */
+    get isModal(): boolean;
+    /** Activate or deactivate; idempotent, so it can be called on every render. */
+    setActive(active: boolean): void;
+    activate(): void;
+    deactivate(): void;
+    /** Move focus into a modal layer once its container has rendered. */
+    didRender(): void;
+    handleEscape(event: KeyboardEvent): void;
+    handleTab(event: KeyboardEvent): void;
+    private restoreFocus;
+}
+/**
+ * Title and description text for a dialog-like content part.
+ *
+ * The `role="dialog"` element lives in the content part's shadow root, while
+ * the title and description are separate custom elements in the light DOM. An
+ * `aria-labelledby` id reference cannot cross that shadow boundary, so the
+ * dialog had no accessible name or description. ARIA element reflection
+ * (`ariaLabelledByElements`) can reach outward, but test tooling and older
+ * engines don't follow it, so the content part mirrors the text into hidden
+ * elements in its own shadow root and references those instead (the approach
+ * `label-association.ts` takes for labels). A MutationObserver keeps the copy
+ * in sync while the content is open.
+ *
+ * Only the title/description that belong to this content part count, not
+ * those of an overlay nested inside it.
+ */
+export declare class DialogLabelSource {
+    private readonly onChange;
+    private observer?;
+    private host;
+    constructor(onChange: (label: string, description: string) => void);
+    private find;
+    private sync;
+    /** Start tracking the content part `host` (call when it opens). */
+    observe(host: HTMLElement): void;
+    disconnect(): void;
+}

package/dist/types/utils/select/types.d.ts

@@ -72,6 +72,10 @@ export interface SelectContext {
     ariaLabelledby?: string;
     /** ID of element that describes this select */
     ariaDescribedby?: string;
+    /** Text that describes this select (set by seki-field; ids can't cross the trigger's shadow root) */
+    ariaDescription?: string;
+    /** 'true' when the select is invalid (set by seki-field) */
+    ariaInvalid?: string;
     /** Handler for value changes */
     onValueChange: (value: SelectValue) => void;
     /** Handler for open state changes */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sekiui/elements",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Modern, accessible Web Components with shadcn/ui-inspired design",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",

package/dist/cdn/p-D50kwTtW.js

@@ -1,160 +0,0 @@
-/**
- * Focus trap utility for dialog and modal components.
- *
- * These helpers walk the *composed* (flattened) tree rather than a single
- * shadow root. Dialog content is projected through a `<slot>`, so the actual
- * focusable elements live in the host's light DOM — and custom elements like
- * `seki-button` keep their focusable `<button>` inside their own shadow root.
- * A plain `container.querySelectorAll()` never sees either, which is why the
- * trap previously matched nothing.
- */
-const FOCUSABLE_SELECTOR = [
-    'a[href]',
-    'button:not([disabled])',
-    'input:not([disabled])',
-    'select:not([disabled])',
-    'textarea:not([disabled])',
-    '[tabindex]:not([tabindex="-1"])',
-    'audio[controls]',
-    'video[controls]',
-    '[contenteditable]:not([contenteditable="false"])',
-].join(', ');
-function isFocusableCandidate(el) {
-    return el instanceof HTMLElement && el.matches(FOCUSABLE_SELECTOR);
-}
-function isHidden(el) {
-    return (el.hidden === true ||
-        el.getAttribute('aria-hidden') === 'true');
-}
-/**
- * Recursively collect focusable elements in composed-tree (DOM) order,
- * descending through shadow roots and resolving `<slot>` assignments.
- */
-function collectFocusable(node, out) {
-    // Resolve slots to their assigned (projected) elements.
-    if (node.tagName === 'SLOT') {
-        const assigned = node.assignedElements({ flatten: true });
-        for (const el of assigned) {
-            collectFocusable(el, out);
-        }
-        return;
-    }
-    // Skip hidden subtrees entirely.
-    if (isHidden(node))
-        return;
-    if (isFocusableCandidate(node)) {
-        out.push(node);
-    }
-    // When an element hosts a shadow root, its rendered subtree is the shadow
-    // tree (light children only surface via slots inside it). Otherwise walk
-    // the light children directly.
-    const children = node.shadowRoot
-        ? Array.from(node.shadowRoot.children)
-        : Array.from(node.children);
-    for (const child of children) {
-        collectFocusable(child, out);
-    }
-}
-/**
- * Get all focusable elements within a container, crossing shadow-DOM and slot
- * boundaries so projected content and nested web components are included.
- */
-function getFocusableElements(container) {
-    var _a;
-    const out = [];
-    const root = (_a = container.shadowRoot) !== null && _a !== void 0 ? _a : container;
-    for (const child of Array.from(root.children)) {
-        collectFocusable(child, out);
-    }
-    return out;
-}
-/**
- * Resolve the deepest active element, descending into nested shadow roots.
- * `document.activeElement` only reports the outermost shadow host.
- */
-function getDeepActiveElement() {
-    var _a;
-    let active = document.activeElement;
-    while ((_a = active === null || active === void 0 ? void 0 : active.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement) {
-        active = active.shadowRoot.activeElement;
-    }
-    return active;
-}
-/**
- * Focus the first focusable element in a container.
- */
-function focusFirst(container) {
-    const focusables = getFocusableElements(container);
-    if (focusables.length > 0) {
-        focusables[0].focus();
-    }
-}
-/**
- * Trap focus within a container during Tab key navigation.
- */
-function trapFocus(container, event) {
-    if (event.key !== 'Tab')
-        return;
-    const focusables = getFocusableElements(container);
-    if (focusables.length === 0) {
-        // Nothing focusable inside — keep focus from escaping the modal.
-        event.preventDefault();
-        return;
-    }
-    const first = focusables[0];
-    const last = focusables[focusables.length - 1];
-    const active = getDeepActiveElement();
-    // `contains()` does not cross shadow boundaries, so detect "escaped" focus by
-    // membership in the composed focusables list instead.
-    const isInside = active !== null && focusables.indexOf(active) !== -1;
-    if (event.shiftKey) {
-        if (active === first || !isInside) {
-            event.preventDefault();
-            last.focus();
-        }
-    }
-    else {
-        if (active === last || !isInside) {
-            event.preventDefault();
-            first.focus();
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Body scroll lock (reference-counted so stacked modals don't unlock early).
-// ---------------------------------------------------------------------------
-let scrollLockCount = 0;
-let savedOverflow = '';
-let savedPaddingRight = '';
-/**
- * Lock body scroll when a modal opens. Safe to nest: the lock is only applied
- * on the first call and the original inline styles are restored on the last
- * matching unlock.
- */
-function lockBodyScroll() {
-    if (scrollLockCount === 0) {
-        savedOverflow = document.body.style.overflow;
-        savedPaddingRight = document.body.style.paddingRight;
-        const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
-        document.body.style.overflow = 'hidden';
-        if (scrollbarWidth > 0) {
-            document.body.style.paddingRight = `${scrollbarWidth}px`;
-        }
-    }
-    scrollLockCount++;
-}
-/**
- * Unlock body scroll when a modal closes. Only the final unlock restores the
- * original inline styles.
- */
-function unlockBodyScroll() {
-    if (scrollLockCount === 0)
-        return;
-    scrollLockCount--;
-    if (scrollLockCount === 0) {
-        document.body.style.overflow = savedOverflow;
-        document.body.style.paddingRight = savedPaddingRight;
-    }
-}
-
-export { focusFirst as f, lockBodyScroll as l, trapFocus as t, unlockBodyScroll as u };

package/dist/cdn/p-DJMgrCw3.js

@@ -1,54 +0,0 @@
-/**
- * Context Bridge Utility
- *
- * Generalizes the "parent publishes state onto its host element + child
- * subscribes via closest()" pattern used by compound components (select,
- * toggle-group, combobox, ...). Each parent calls publishContext() from its
- * updateContextOnElement()-equivalent method; each child calls
- * subscribeToContextChange() once in componentDidLoad() and the returned
- * unsubscribe() in disconnectedCallback().
- *
- * Extracted after the same bug (child freezes at mount-time state because
- * nothing told it the parent changed) was independently fixed three times
- * for select (#244/#253), toggle-group (#255/#257), and combobox (#258/#259).
- */
-/**
- * One event name shared by every compound-component family. Stencil's
- * @Event() emits with { bubbles: true, composed: true } by default, so a
- * nested compound (e.g. a toggle-group rendered inside a select) can cause an
- * inner parent's event to bubble past an outer parent's own children. This is
- * harmless today only because subscribeToContextChange()'s callback takes no
- * payload and every handler re-reads its own closest() parent's live context
- * rather than trusting event.detail — do not add a payload to this event or
- * that bubbling becomes a real cross-family bug.
- */
-const SEKI_CONTEXT_CHANGE_EVENT = 'sekiContextChange';
-/**
- * Parent-side: publish a fresh context object onto the host element and
- * notify subscribed children. Must assign a plain property, not a class
- * accessor of the same name — in the dist-custom-elements build the class
- * IS the host element, so an accessor collision throws (#254).
- */
-function publishContext(el, propertyName, context, emitter) {
-    el[propertyName] = context;
-    emitter.emit();
-}
-/**
- * Child-side: find the nearest ancestor matching parentSelector and listen
- * for context-change notifications. onChange is called with no payload by
- * design — children re-read the live context property via closest() rather
- * than trusting a stale event.detail snapshot. No-ops safely (null parent,
- * no-op unsubscribe) if no matching parent is found.
- */
-function subscribeToContextChange(el, parentSelector, onChange) {
-    const parent = el.closest(parentSelector);
-    if (parent) {
-        parent.addEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange);
-    }
-    return {
-        parent,
-        unsubscribe: () => parent === null || parent === void 0 ? void 0 : parent.removeEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange),
-    };
-}
-
-export { publishContext as p, subscribeToContextChange as s };

package/dist/cjs/context-bridge-CywF7uJm.js

@@ -1,57 +0,0 @@
-'use strict';
-
-/**
- * Context Bridge Utility
- *
- * Generalizes the "parent publishes state onto its host element + child
- * subscribes via closest()" pattern used by compound components (select,
- * toggle-group, combobox, ...). Each parent calls publishContext() from its
- * updateContextOnElement()-equivalent method; each child calls
- * subscribeToContextChange() once in componentDidLoad() and the returned
- * unsubscribe() in disconnectedCallback().
- *
- * Extracted after the same bug (child freezes at mount-time state because
- * nothing told it the parent changed) was independently fixed three times
- * for select (#244/#253), toggle-group (#255/#257), and combobox (#258/#259).
- */
-/**
- * One event name shared by every compound-component family. Stencil's
- * @Event() emits with { bubbles: true, composed: true } by default, so a
- * nested compound (e.g. a toggle-group rendered inside a select) can cause an
- * inner parent's event to bubble past an outer parent's own children. This is
- * harmless today only because subscribeToContextChange()'s callback takes no
- * payload and every handler re-reads its own closest() parent's live context
- * rather than trusting event.detail — do not add a payload to this event or
- * that bubbling becomes a real cross-family bug.
- */
-const SEKI_CONTEXT_CHANGE_EVENT = 'sekiContextChange';
-/**
- * Parent-side: publish a fresh context object onto the host element and
- * notify subscribed children. Must assign a plain property, not a class
- * accessor of the same name — in the dist-custom-elements build the class
- * IS the host element, so an accessor collision throws (#254).
- */
-function publishContext(el, propertyName, context, emitter) {
-    el[propertyName] = context;
-    emitter.emit();
-}
-/**
- * Child-side: find the nearest ancestor matching parentSelector and listen
- * for context-change notifications. onChange is called with no payload by
- * design — children re-read the live context property via closest() rather
- * than trusting a stale event.detail snapshot. No-ops safely (null parent,
- * no-op unsubscribe) if no matching parent is found.
- */
-function subscribeToContextChange(el, parentSelector, onChange) {
-    const parent = el.closest(parentSelector);
-    if (parent) {
-        parent.addEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange);
-    }
-    return {
-        parent,
-        unsubscribe: () => parent === null || parent === void 0 ? void 0 : parent.removeEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange),
-    };
-}
-
-exports.publishContext = publishContext;
-exports.subscribeToContextChange = subscribeToContextChange;