@radix-ng/primitives 1.0.0-beta.2 → 1.0.0-beta.4

package/fesm2022/radix-ng-primitives-core.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { forwardRef, input, booleanAttribute, output, linkedSignal, untracked, Directive, inject, InjectionToken, computed, APP_ID, Injectable, DOCUMENT, PLATFORM_ID, DestroyRef, signal, afterNextRender, effect, ElementRef, assertInInjectionContext, Injector } from '@angular/core';
+import { forwardRef, input, booleanAttribute, output, linkedSignal, untracked, Directive, inject, isDevMode, HOST_TAG_NAME, ElementRef, InjectionToken, computed, APP_ID, Injectable, DOCUMENT, PLATFORM_ID, DestroyRef, signal, effect, afterNextRender, assertInInjectionContext, Injector } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { getLocalTimeZone, CalendarDateTime, ZonedDateTime, getDayOfWeek, DateFormatter, createCalendar, toCalendar, CalendarDate, Time, startOfMonth, endOfMonth, today } from '@internationalized/date';
 import { isPlatformBrowser, DOCUMENT as DOCUMENT$1 } from '@angular/common';
@@ -181,13 +181,125 @@ function snapValueToStep(value, min, max, step) {
     return snappedValue;
 }
 
-// Thanks for idea.
-// https://github.com/unovue/reka-ui/blob/v2/packages/core/src/shared/createContext.ts
 /**
  * Base URL of the documentation site. Each primitive's docs are also served as plain
  * Markdown at `/<section>/<slug>.md`, which both humans and AI agents can open.
  */
 const DOCS_BASE_URL = 'https://radix-ng.com';
+/**
+ * Full URL to a primitive's plain-Markdown docs page.
+ * @param docsPath Documentation path for the owning primitive (e.g. `'components/select'`).
+ */
+function docsUrl(docsPath) {
+    return `${DOCS_BASE_URL}/${docsPath}.md`;
+}
+/**
+ * Codes already warned this page load, keyed by their stable `<primitive>/<slug>` code.
+ * `rdxDevWarning` consults this so each distinct misuse warns at most once.
+ */
+const warnedCodes = new Set();
+function formatMessage(code, message, docsPath) {
+    const hint = docsPath ? ` See ${docsUrl(docsPath)}` : '';
+    return `[rdx:${code}] ${message}${hint}`;
+}
+/**
+ * Emits a deduplicated dev-mode `console.warn` for a recoverable misuse.
+ *
+ * No-op outside `isDevMode()`, so production builds stay silent (and the message
+ * assembly tree-shakes out). Dedupes per `code` per page load, replacing the
+ * hand-rolled `warned` flags individual primitives used to carry.
+ *
+ * @param code Stable, greppable `<primitive>/<slug>` identifier (e.g. `'select/trigger-element'`).
+ * @param message Human-readable explanation of the misuse and how to fix it.
+ * @param docsPath Optional docs path appended as a `See <url>` hint (e.g. `'components/select'`).
+ */
+function rdxDevWarning(code, message, docsPath) {
+    if (!isDevMode() || warnedCodes.has(code)) {
+        return;
+    }
+    warnedCodes.add(code);
+    console.warn(formatMessage(code, message, docsPath));
+}
+/**
+ * Throws a dev-mode `Error` for unrecoverable misuse (broken markup that cannot work).
+ *
+ * Unlike {@link rdxDevWarning} this always throws when reached — callers that want the
+ * check to stay dev-only should guard the call with `isDevMode()`.
+ *
+ * @param code Stable, greppable `<primitive>/<slug>` identifier (e.g. `'popover/portal-on-element'`).
+ * @param message Human-readable explanation of the misuse and how to fix it.
+ * @param docsPath Optional docs path appended as a `See <url>` hint (e.g. `'components/popover'`).
+ */
+function rdxDevError(code, message, docsPath) {
+    throw new Error(formatMessage(code, message, docsPath));
+}
+/**
+ * Test-only: clears the per-code dedup set so warning specs stay isolated from one another.
+ */
+function resetRdxDevWarnings() {
+    warnedCodes.clear();
+}
+/** Natively focusable / keyboard-operable host elements a trigger may live on without extra wiring. */
+const INTERACTIVE_TRIGGER_TAGS = new Set(['button', 'a', 'input']);
+/**
+ * Dev-mode check: warns when a trigger part sits on a host element that is neither natively
+ * interactive (`<button>`, `<a>`, `<input>`) nor made focusable with `tabindex`.
+ *
+ * Only meaningful for triggers whose selector accepts arbitrary elements **and** that do not
+ * adapt their own ARIA/keyboard handling for non-button hosts — triggers scoped to
+ * `button[...]` already enforce this at the selector level, and triggers that auto-apply
+ * `role`/`tabindex` (e.g. `rdxMenuTrigger`) handle it themselves.
+ *
+ * Must be called inside an injection context (a directive constructor), where the host element
+ * already exists. No-op outside `isDevMode()` and on synthetic hosts (component / `ng-template`),
+ * where `HOST_TAG_NAME` is absent.
+ *
+ * @param triggerName Selector name used in the message, e.g. `'rdxPreviewCardTrigger'`.
+ * @param code Stable diagnostics code, e.g. `'preview-card/trigger-element'`.
+ * @param docsPath Docs path for the See-link, e.g. `'components/preview-card'`.
+ */
+function rdxCheckTriggerElement(triggerName, code, docsPath) {
+    if (!isDevMode()) {
+        return;
+    }
+    const tag = inject(HOST_TAG_NAME, { optional: true })?.toLowerCase();
+    if (!tag || INTERACTIVE_TRIGGER_TAGS.has(tag)) {
+        return;
+    }
+    // A consumer-supplied `tabindex` means they opted the element into focusability deliberately.
+    if (inject(ElementRef).nativeElement.hasAttribute('tabindex')) {
+        return;
+    }
+    rdxDevWarning(code, `\`${triggerName}\` is on a <${tag}>, which is not focusable or keyboard-operable by default. ` +
+        `Use a native <button> or <a>, or add an appropriate \`role\` and \`tabindex\` so keyboard ` +
+        `and assistive-technology users can reach it.`, docsPath);
+}
+/**
+ * Dev-mode check: warns when a label part sits on a non-`<label>` host. The `for` attribute only
+ * associates a `<label>` with a control, so a label part placed on any other element is not
+ * programmatically connected to its control.
+ *
+ * Must be called inside an injection context. No-op outside `isDevMode()` and on synthetic hosts.
+ *
+ * @param labelName Selector name used in the message, e.g. `'rdxFieldLabel'`.
+ * @param code Stable diagnostics code, e.g. `'field/unassociated-label'`.
+ * @param docsPath Docs path for the See-link, e.g. `'components/field'`.
+ */
+function rdxCheckLabelElement(labelName, code, docsPath) {
+    if (!isDevMode()) {
+        return;
+    }
+    const tag = inject(HOST_TAG_NAME, { optional: true })?.toLowerCase();
+    if (!tag || tag === 'label') {
+        return;
+    }
+    rdxDevWarning(code, `\`${labelName}\` is on a <${tag}>. The \`for\` attribute only associates a <label> with a ` +
+        `control, so this label is not programmatically connected to its control. Place it on a ` +
+        `<label>, or associate the control another way (e.g. \`aria-labelledby\`).`, docsPath);
+}
+
+// Thanks for idea.
+// https://github.com/unovue/reka-ui/blob/v2/packages/core/src/shared/createContext.ts
 /**
  * Creates a context with injector and provider functions for a given type
  * @template T The type of the context value
@@ -214,7 +326,7 @@ function createContext(description, docs) {
         // provided factory that returns null/undefined for the non-optional case.
         const value = inject(CONTEXT_TOKEN, { optional: true });
         if (value == null && !optional) {
-            const docsHint = docs ? ` See ${DOCS_BASE_URL}/${docs}.md for the required part hierarchy.` : '';
+            const docsHint = docs ? ` See ${docsUrl(docs)} for the required part hierarchy.` : '';
             throw new Error(`No \`${contextName}\` found. This part must be placed inside the directive ` +
                 `that provides \`${contextName}\` (usually the primitive's root).${docsHint}`);
         }
@@ -1915,6 +2027,909 @@ function provideToken(token, type) {
     };
 }
 
+function createCancelableChangeEventDetails(reason, event, trigger) {
+    let canceled = false;
+    let preventUnmountOnClose = false;
+    return {
+        eventDetails: {
+            reason,
+            event,
+            trigger,
+            cancel: () => {
+                canceled = true;
+            },
+            isCanceled: () => canceled,
+            preventUnmountOnClose: () => {
+                preventUnmountOnClose = true;
+            }
+        },
+        shouldPreventUnmountOnClose: () => preventUnmountOnClose
+    };
+}
+
+/**
+ * Creates an {@link RdxFloatingEvents} emitter backed by `Map<event, Set<listener>>`, mirroring Base
+ * UI's implementation: synchronous dispatch, set-deduplicated listeners, no replay.
+ *
+ * **Snapshot dispatch:** `emit()` snapshots the listener set before iterating so that a listener
+ * calling `on()`/`off()` during dispatch does not cause skip/revisit issues.
+ */
+function createFloatingEvents() {
+    const listeners = new Map();
+    return {
+        emit(event, data) {
+            const set = listeners.get(event);
+            if (!set)
+                return;
+            // Snapshot avoids mutation-during-dispatch (on()/off() in a listener).
+            for (const listener of [...set]) {
+                listener(data);
+            }
+        },
+        on(event, listener) {
+            let set = listeners.get(event);
+            if (!set) {
+                set = new Set();
+                listeners.set(event, set);
+            }
+            set.add(listener);
+        },
+        off(event, listener) {
+            listeners.get(event)?.delete(listener);
+        }
+    };
+}
+
+const DOCS$2 = 'utils/floating-tree';
+/**
+ * A **stable DI handle** created at injector formation time and filled in at runtime once the
+ * registration directive resolves its `externalTree` / `parentOverride` inputs.
+ *
+ * **Why a handle, not direct token replacement.** Angular injectors are sealed at creation — a
+ * directive that resolves its tree from a runtime `externalTree` input cannot change what
+ * `RDX_FLOATING_TREE` resolves to for its subtree afterwards. The handle is the object that _is_
+ * provided at creation; its internal state signal changes at runtime. Descendants inject the handle
+ * (with `skipSelf: true`) and read `parentReg.tree()` / `parentReg.node()` reactively — they never
+ * depend on tokens being swapped post-construction.
+ *
+ * **Atomicity.** `tree` and `node` are **not** separate `WritableSignal`s — independent `.set()`
+ * calls would create intermediate states where `node.tree !== tree`. Instead there is **one** private
+ * {@link RegistrationState} signal; `register(tree, node)` sets the `registered` payload after asserting
+ * `node.tree === tree`, `markDetached()` records "resolved, no node", and `clear()` reverts to
+ * `pending`. The `tree`/`node`/`status` reads are `computed()` over that one signal, so they can never
+ * disagree.
+ *
+ * **Registration directive usage pattern:**
+ *
+ * ```ts
+ * @Directive({ providers: [provideFloatingRegistration()] })
+ * class SomeFloatingDirective {
+ *   // Own handle — the WRITER side. Inject the concrete type so register()/markDetached()/clear() are
+ *   // available; this is the only place that writes this handle.
+ *   private readonly selfReg = inject(RdxFloatingRegistrationContext);
+ *   // Parent handle — the READER side (token is reader-typed). A descendant can read status/tree/node
+ *   // but cannot mutate the parent's registration.
+ *   private readonly parentReg  = inject(RDX_FLOATING_REGISTRATION, { optional: true, skipSelf: true });
+ *   private readonly ambientTree = inject(RDX_FLOATING_TREE, { optional: true });
+ *
+ *   constructor() {
+ *     effect((onCleanup) => {
+ *       const override = this.parentOverride(); // { kind: 'inherit' | 'root' | 'node' }
+ *
+ *       // ONLY an `inherit` node depends on the DI parent, so only it waits on a `pending` parent (a
+ *       // `pending` parent is NOT "no parent"; reading status() subscribes us, so we re-run when it
+ *       // flips). `root` / `node` overrides are independent of the DI ancestor and register NOW —
+ *       // waiting on the DI parent would wrongly stall them, or strand them if that parent is destroyed.
+ *       if (override.kind === 'inherit' && this.parentReg?.status() === 'pending') return;
+ *
+ *       // Logical parent from the override (DI parent only for `inherit`; a `detached` parent reads
+ *       // null → this node becomes a root in its tree).
+ *       const parentNode =
+ *         override.kind === 'node' ? override.parent
+ *         : override.kind === 'root' ? null
+ *         : (this.parentReg?.node() ?? null); // 'inherit'
+ *
+ *       // Tree selection (resolveFloatingTree's logic; inject() is illegal inside effect()). A `node`
+ *       // override must join its parent's tree.
+ *       const externalTree = this.externalTreeInput(); // input() signal
+ *       const resolvedTree =
+ *         (override.kind === 'node' ? override.parent.tree : undefined) ??
+ *         externalTree ?? this.parentReg?.tree() ?? this.ambientTree;
+ *       if (!resolvedTree) {
+ *         this.selfReg.markDetached(); // node-optional: resolved, but no tree → no node
+ *         return;
+ *       }
+ *
+ *       const node = resolvedTree.register({ id: ..., parent: parentNode, context: ... });
+ *       this.selfReg.register(resolvedTree, node);
+ *
+ *       onCleanup(() => {
+ *         resolvedTree.unregister(node);
+ *         this.selfReg.clear(); // transient: back to 'pending' until the effect re-resolves
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ */
+class RdxFloatingRegistrationContext {
+    constructor() {
+        this._state = signal({ status: 'pending' }, ...(ngDevMode ? [{ debugName: "_state" }] : /* istanbul ignore next */ []));
+        /**
+         * Lifecycle phase: `pending` (resolving — children must wait), `detached` (resolved, node-optional),
+         * or `registered`. A `computed()` over the one internal state signal. See {@link RegistrationState}.
+         */
+        this.status = computed(() => this._state().status, ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+        /**
+         * The tree this directive joined, or `null` unless `status() === 'registered'`. A `computed()`
+         * derived from the internal state — always consistent with {@link node} and {@link status}.
+         */
+        this.tree = computed(() => {
+            const state = this._state();
+            return state.status === 'registered' ? state.tree : null;
+        }, ...(ngDevMode ? [{ debugName: "tree" }] : /* istanbul ignore next */ []));
+        /**
+         * The node this directive registered, or `null` unless `status() === 'registered'`. A `computed()`
+         * derived from the internal state — always consistent with {@link tree}
+         * (`node.tree === tree` is invariant in the `registered` state).
+         */
+        this.node = computed(() => {
+            const state = this._state();
+            return state.status === 'registered' ? state.node : null;
+        }, ...(ngDevMode ? [{ debugName: "node" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Atomically records the resolved tree and the registered node (`status → 'registered'`). Asserts
+     * `node.tree === tree` so no state where `tree` and `node` point to different stores can exist.
+     * Called by the directive inside `effect()` after `tree.register(…)` succeeds.
+     */
+    register(tree, node) {
+        if (node.tree !== tree) {
+            rdxDevError('floating/registration-mismatch', `register(tree, node): node.tree must equal tree. ` + `Node "${node.id}" belongs to a different tree.`, DOCS$2);
+        }
+        this._state.set({ status: 'registered', tree, node });
+    }
+    /**
+     * Records that the directive **resolved but has no node** (`status → 'detached'`): node-optional —
+     * no tree was available (e.g. a standalone `rdxDismissableLayer`). Distinct from `pending`: a child
+     * treats a `detached` parent as absent (inherits `null`), whereas it must **wait** on a `pending` one.
+     */
+    markDetached() {
+        this._state.set({ status: 'detached' });
+    }
+    /**
+     * Reverts to `pending` (the `onCleanup` counterpart of {@link register} / {@link markDetached}).
+     * Called after `tree.unregister(node)` so the handle re-enters the "resolving" phase until the
+     * directive's effect re-runs; `tree`/`node` read `null` again.
+     */
+    clear() {
+        this._state.set({ status: 'pending' });
+    }
+}
+/**
+ * DI token for the nearest ancestor's registration handle, **typed as the read-only
+ * {@link RdxFloatingRegistrationReader}**. A descendant injects it with `{ optional: true, skipSelf:
+ * true }` to read its parent's `status` / `tree` / `node` — and, because the token is reader-typed,
+ * **cannot** call the parent's writers (`register` / `markDetached` / `clear`) without a deliberate
+ * cast. The owning directive writes through its own handle, which it injects by the concrete
+ * {@link RdxFloatingRegistrationContext} type instead (see {@link provideFloatingRegistration}).
+ */
+const RDX_FLOATING_REGISTRATION = new InjectionToken('RdxFloatingRegistration');
+/**
+ * Seals a fresh registration handle into this directive's injector at creation time. Returns **two**
+ * providers backed by **one** instance: the concrete {@link RdxFloatingRegistrationContext} (the
+ * writer, injected by the owning directive) and a reader-typed {@link RDX_FLOATING_REGISTRATION} alias
+ * (`useExisting`) that descendants inject. Splitting writer from reader is what stops a descendant from
+ * mutating its parent's registration. Call this in a directive's `providers` array; the directive then
+ * calls `selfReg.register(tree, node)` / `markDetached()` / `clear()` on its own (writer) handle.
+ */
+function provideFloatingRegistration() {
+    return [
+        { provide: RdxFloatingRegistrationContext, useFactory: () => new RdxFloatingRegistrationContext() },
+        { provide: RDX_FLOATING_REGISTRATION, useExisting: RdxFloatingRegistrationContext }
+    ];
+}
+
+/** Not exported — the only handle to a node's mutable state, so consumers cannot bypass the tree. */
+const nodeInternals = new WeakMap();
+/**
+ * Module-private construction key. The {@link RdxFloatingNode} constructor requires it, and its type is
+ * a non-exported `unique symbol`, so consumers can neither name it (compile error) nor produce it
+ * (runtime guard) — a node can only be created through {@link RdxFloatingTree.register}, never a loose
+ * `new RdxFloatingNode(...)` that would exist outside `tree.all`.
+ */
+const NODE_CONSTRUCT_KEY = Symbol('RdxFloatingNode');
+/**
+ * A neutral node in the shared floating tree — the Angular counterpart of Base UI's `FloatingNode`
+ * (`{ id, parentId, context? }`). It is deliberately **lightweight**: tree membership only. The
+ * popup's `open` state, trigger registry, and elements live on the separate {@link
+ * RdxFloatingRootContext}, exactly as Base UI splits `FloatingNode` from `FloatingRootStore`.
+ *
+ * `parent` and `context` are exposed **read-only**; they are mutated **only** through {@link
+ * RdxFloatingTree.setParent} / {@link RdxFloatingTree.setContext} (which enforce the cycle and
+ * owner-`Document` invariants). The backing state is held in a module-private `WeakMap`, so a consumer
+ * cannot reach around the tree with `node.parent = …` / `node.context = …`.
+ *
+ * `context` may be `null` (a contextless intermediate node). Open-ness is read from the context — there
+ * is no `open` on the node — and tree traversal's `onlyOpen` filter reads `node.context?.open()`,
+ * mirroring Base UI's `getNodeChildren` filtering on `child.context?.open`. Presence (`mounted`) is
+ * implicit: a node is mounted **iff** it is registered in the tree.
+ */
+class RdxFloatingNode {
+    /** @internal — constructed only by {@link RdxFloatingTree.register} (guarded by a module-private key). */
+    constructor(construct, id, tree, parent, context) {
+        this.id = id;
+        if (construct !== NODE_CONSTRUCT_KEY) {
+            rdxDevError('floating/direct-node-construction', 'RdxFloatingNode is created only by RdxFloatingTree.register().', DOCS$1);
+        }
+        this.tree = tree;
+        nodeInternals.set(this, { parent, context });
+    }
+    /** Resolved **logical** parent (DI-derived). Reassign via {@link RdxFloatingTree.setParent}. */
+    get parent() {
+        return nodeInternals.get(this).parent;
+    }
+    /** The per-popup root context/store. `null` for a contextless node. Reassign via `tree.setContext`. */
+    get context() {
+        return nodeInternals.get(this).context;
+    }
+}
+const DOCS$1 = 'utils/floating-tree';
+/** A node's open-state — read from its context (no `open` on the node itself). */
+function nodeIsOpen(node) {
+    return node.context?.open() ?? false;
+}
+/**
+ * The shared floating tree (node store) — the Angular counterpart of Base UI's `FloatingTreeStore`.
+ *
+ * It owns a flat set of {@link RdxFloatingNode | nodes} linked by `parent`, an adjacency index for
+ * O(1) child lookup, and a neutral typed {@link RdxFloatingEvents | event channel}. It owns **neither**
+ * trigger registries **nor** `open` state — those live per-popup on each {@link RdxFloatingRootContext}
+ * (Base UI keeps them on the root store, not the tree store). Dismissal (ADR 0015) and the focus
+ * manager (ADR 0017) read the **same** nodes, traversal, and events; neither owns the tree.
+ *
+ * Ancestry is **logical** (DI-derived), not DOM-derived, so portal relocation never changes ownership
+ * (ADR 0015 §1). Independent roots are **not** coordinated against each other (Base UI parity): the
+ * tree only answers questions *within* itself.
+ *
+ * **Performance:** `isRegistered()` is O(1) via `nodeSet`; `directChildren()` is O(1) via the
+ * `childrenOf` adjacency map; `ancestors()` is O(depth); `children()` is O(n) total.
+ */
+class RdxFloatingTree {
+    constructor() {
+        /**
+         * Neutral typed event channel (hover-close, virtual focus, menu coordination, list nav). Private to
+         * this tree, which is scoped-by-default (one per coordinating root via `provideFloatingTree()`), so
+         * events never leak across unrelated popups — matching Base UI's per-`FloatingTree` events.
+         */
+        this.events = createFloatingEvents();
+        /** O(1) membership test and snapshot for `all`. */
+        this.nodeSet = new Set();
+        /**
+         * Adjacency index: maps each node (or `null` for root nodes) to its direct children in
+         * registration order. Maintained in sync by `register`, `unregister`, and `setParent`.
+         * Eliminates the O(n) `filter` per node in recursive traversal. Invariant: only **non-empty**
+         * arrays are stored — an entry is pruned the moment its last child leaves, so a key never
+         * outlives its node (see `removeFromChildrenOf`).
+         */
+        this.childrenOf = new Map();
+    }
+    /** Registers a new node. `init.parent` must already be resolved (DI layer handles `inherit`). */
+    register(init) {
+        // Structural integrity — ALWAYS (a foreign/unregistered parent corrupts the tree, not just dev misuse).
+        this.assertRegisterableParent(init.parent);
+        if (isDevMode()) {
+            // Validate the new context against the nearest context-bearing ancestor (through any
+            // contextless intermediates). A fresh node has no descendants yet. (dev-only — cheap check
+            // of correct usage, not a structural invariant.)
+            this.assertContextDocument(init.context, this.nearestContext(init.parent));
+        }
+        const node = new RdxFloatingNode(NODE_CONSTRUCT_KEY, init.id, this, init.parent, init.context);
+        this.nodeSet.add(node);
+        this.addToChildrenOf(init.parent, node);
+        return node;
+    }
+    /** Removes a node from the tree. Children are **not** removed — they keep their `parent` reference. */
+    unregister(node) {
+        if (isDevMode()) {
+            this.assertOwnedNode(node);
+        }
+        this.nodeSet.delete(node);
+        this.removeFromChildrenOf(node.parent, node);
+        // `childrenOf.get(node)` (this node's OWN child list) is intentionally NOT cleared here while
+        // it still has registered children: those orphans keep their `parent` ref and must be able to
+        // remove themselves later. The key is pruned automatically once the last orphan unregisters
+        // (removeFromChildrenOf deletes empty lists), so the node is not retained. Orphans are never
+        // reached by traversal meanwhile, since isRegistered(node) = false.
+    }
+    /**
+     * Associates / re-associates / clears a node's root context after registration (Base UI attaches
+     * the context once the floating element resolves). Validates the new context's owner-`Document`
+     * against the nearest context-bearing **ancestor** (through contextless intermediates) **and**
+     * every context-bearing **descendant**, so a contextless intermediate can never bridge two
+     * documents. Allows the `null → context → null` lifecycle.
+     */
+    setContext(node, context) {
+        // Structural integrity — ALWAYS (mutating a foreign node corrupts another tree).
+        this.assertOwnedNode(node);
+        if (isDevMode() && context !== null) {
+            // dev-only: expensive ancestry/subtree document validation.
+            this.assertContextDocument(context, this.nearestContext(node.parent));
+            for (const dc of this.descendantContexts(node)) {
+                this.assertContextDocument(context, dc);
+            }
+        }
+        nodeInternals.get(node).context = context;
+    }
+    /** Reparents an existing node (detached composition / explicit `node` override), with cycle guard. */
+    setParent(node, parent) {
+        // Structural integrity — ALWAYS (a foreign node, or a foreign/unregistered parent, corrupts the tree).
+        this.assertOwnedNode(node);
+        this.assertRegisterableParent(parent);
+        // No-op reparent: the parent is unchanged, so there is nothing to do — and crucially we must
+        // NOT fall through, because removeFromChildrenOf + addToChildrenOf would move `node` to the
+        // END of its sibling list, silently changing traversal/focus order (Base UI keeps node order
+        // stable). The guards above still run, so a foreign/unregistered node is rejected first.
+        if (node.parent === parent) {
+            return;
+        }
+        // The cycle check is ALSO structural — a cycle would make traversal (children / ancestors /
+        // nearestContext) recurse/loop forever — so it runs in production too. Walk the
+        // prospective parent chain (stopping at an unregistered node, like `ancestors`); reaching `node`
+        // means an ancestry cycle. O(depth).
+        for (let ancestor = parent; ancestor !== null && this.nodeSet.has(ancestor); ancestor = ancestor.parent) {
+            if (ancestor === node) {
+                rdxDevError('floating/parent-cycle', `Reparenting node "${node.id}" under "${parent?.id}" creates an ancestry cycle.`, DOCS$1);
+            }
+        }
+        if (isDevMode()) {
+            // dev-only: validate the WHOLE subtree against the new ancestry.
+            this.assertSubtreeDocuments(node, parent);
+        }
+        const oldParent = node.parent; // capture before updating internals
+        nodeInternals.get(node).parent = parent;
+        this.removeFromChildrenOf(oldParent, node);
+        this.addToChildrenOf(parent, node);
+    }
+    /**
+     * Direct + transitive children, in registration order. The `onlyOpen` filter (default `true`)
+     * filters the **result** by each node's `context?.open()` lifecycle but **never** aborts recursion
+     * at a closed node, so a keep-mounted/closed parent never hides an open grandchild (Base UI
+     * `getNodeChildren`, ADR 0015 §1 traversal contract).
+     *
+     * Dismissal children queries pass `onlyOpen: true` (the `hasBlockingChild` pattern in the
+     * capability). The focus manager's focus-return check passes `onlyOpen: false` explicitly (Base UI
+     * `FloatingFocusManager.tsx:842`) — so focus inside a closed-but-mounted descendant still counts as
+     * "inside the tree". Always pass `onlyOpen` explicitly for non-dismissal paths; do not inherit the
+     * default.
+     */
+    children(node, options = {}) {
+        if (isDevMode()) {
+            this.assertOwnedNode(node);
+        }
+        const onlyOpen = options.onlyOpen ?? true;
+        const result = [];
+        const collect = (parent) => {
+            for (const candidate of this.directChildren(parent)) {
+                if (!onlyOpen || nodeIsOpen(candidate)) {
+                    result.push(candidate);
+                }
+                // Recurse regardless of the candidate's open-ness (never abort at a closed node).
+                collect(candidate);
+            }
+        };
+        collect(node);
+        return result;
+    }
+    /**
+     * Logical ancestors of `node`, nearest first (Base UI `getNodeAncestors`). The walk **stops at an
+     * unregistered node**: Base UI resolves ancestry by `parentId` lookup in the live nodes array, so
+     * unregistering a parent breaks the chain (a removed middle node truncates ancestry — its children
+     * keep the raw `parent` identity but it no longer appears as an ancestor). This avoids a "ghost"
+     * ancestor lingering in DI-ownership / document / dismissal/focus traversal when Angular destroys a
+     * parent before its child.
+     */
+    ancestors(node) {
+        if (isDevMode()) {
+            this.assertOwnedNode(node);
+        }
+        const result = [];
+        for (let current = node.parent; current !== null && this.nodeSet.has(current); current = current.parent) {
+            result.push(current);
+        }
+        return result;
+    }
+    /** Snapshot of all registered nodes (debugging / diagnostics). Registration order is preserved. */
+    get all() {
+        return [...this.nodeSet];
+    }
+    // ─── Private adjacency helpers ───────────────────────────────────────────
+    /** Direct children of `parent` in registration order. O(1) via the adjacency map. */
+    directChildren(parent) {
+        return this.childrenOf.get(parent) ?? [];
+    }
+    addToChildrenOf(parent, node) {
+        let children = this.childrenOf.get(parent);
+        if (!children) {
+            children = [];
+            this.childrenOf.set(parent, children);
+        }
+        children.push(node);
+    }
+    removeFromChildrenOf(parent, node) {
+        const children = this.childrenOf.get(parent);
+        if (!children)
+            return;
+        const idx = children.indexOf(node);
+        if (idx !== -1)
+            children.splice(idx, 1);
+        // Prune the now-empty list so its `parent` key (a STRONG ref to a node) is released. Without
+        // this an unregistered node that ever had a child lingers as a map key forever — retaining the
+        // node → context → floating/reference DOM elements (a leak that grows on every nested
+        // mount/unmount). `childrenOf` therefore only ever holds non-empty arrays.
+        if (children.length === 0) {
+            this.childrenOf.delete(parent);
+        }
+    }
+    // ─── Private traversal helpers ───────────────────────────────────────────
+    /**
+     * Nearest context-bearing node walking up from `node` (inclusive), skipping contextless ancestors.
+     * Stops at an unregistered node (same ghost-ancestry rule as {@link ancestors}).
+     */
+    nearestContext(node) {
+        for (let current = node; current !== null && this.nodeSet.has(current); current = current.parent) {
+            if (current.context !== null) {
+                return current.context;
+            }
+        }
+        return null;
+    }
+    /** All contexts among `node`'s transitive descendants (skips `node` itself). */
+    descendantContexts(node) {
+        return this.children(node, { onlyOpen: false })
+            .map((descendant) => descendant.context)
+            .filter((context) => context !== null);
+    }
+    /**
+     * Dev-only: validates every context in `node`'s subtree (node + transitive descendants) against
+     * the nearest context-bearing ancestor walking up from `newParent`. Shared between `setParent`
+     * (moves a subtree under a new parent) to keep the document-consistency rule in one place.
+     */
+    assertSubtreeDocuments(node, newParent) {
+        const ancestorCtx = this.nearestContext(newParent);
+        this.assertContextDocument(node.context, ancestorCtx);
+        for (const dc of this.descendantContexts(node)) {
+            this.assertContextDocument(dc, ancestorCtx);
+        }
+    }
+    // ─── Private invariant guards ─────────────────────────────────────────────
+    /** Whether `node` is currently registered in this tree. O(1). */
+    isRegistered(node) {
+        return this.nodeSet.has(node);
+    }
+    /**
+     * Guards that `node` actually belongs to **this** tree and is still registered — so a tree can
+     * never mutate/traverse a node owned by another tree (which would leave `node.tree` pointing
+     * elsewhere while its ancestry leads here) or one that was already unregistered.
+     */
+    assertOwnedNode(node) {
+        if (node.tree !== this || !this.nodeSet.has(node)) {
+            rdxDevError('floating/foreign-node', 'This node does not belong to this tree (or was already unregistered).', DOCS$1);
+        }
+    }
+    /** A parent (when given) must belong to this tree **and** still be registered. */
+    assertRegisterableParent(parent) {
+        if (parent !== null) {
+            if (parent.tree !== this) {
+                rdxDevError('floating/cross-tree-parent', 'A floating node parent must belong to the same tree.', DOCS$1);
+            }
+            if (!this.nodeSet.has(parent)) {
+                rdxDevError('floating/unregistered-parent', 'A floating node parent must be currently registered in the tree.', DOCS$1);
+            }
+        }
+    }
+    /** Owner-`Document` consistency between a node's context and a related (ancestor/descendant) context. */
+    assertContextDocument(context, relatedContext) {
+        if (context !== null && relatedContext !== null && context.ownerDocument !== relatedContext.ownerDocument) {
+            rdxDevError('floating/cross-document-parent', 'A floating node must share the same ownerDocument as its ancestry/subtree.', DOCS$1);
+        }
+    }
+}
+
+/**
+ * The nearest shared {@link RdxFloatingTree}. **Scoped-by-default, sharing explicit** — strict Base UI
+ * parity: Base UI creates a `FloatingTree` only at the **coordination boundary** (e.g. a top-level Menu
+ * renders `<FloatingTree>`, a nested submenu does **not** — it inherits the parent's store,
+ * `MenuRoot.tsx:533`). There is deliberately **no** application-root provider, so the token resolves only
+ * under a root that opts in with {@link provideFloatingTree}; elsewhere injecting it optionally yields
+ * `null` and the primitive is its own independent root (`parent === null`).
+ */
+const RDX_FLOATING_TREE = new InjectionToken('RdxFloatingTree');
+/**
+ * Provides a {@link RdxFloatingTree} for a subtree — the Angular `FloatingTree` analogue. **Inherit-or-
+ * create:** it returns the **nearest ancestor tree** if one is already provided above, and creates a new
+ * one **only at the top coordination boundary**. This is what makes it safe for a nesting-capable root
+ * (Menu/Menubar/Context Menu/nested Dialog) to put it in `providers` unconditionally — a **nested**
+ * instance inherits the parent's tree (so its node parents correctly), while the **top** instance starts
+ * the store. (An always-new tree on a nested root would split ancestry / throw `cross-tree-parent`.)
+ *
+ * **Tree selection is separate from parent assignment** (Base UI: `tree = externalTree ?? contextTree`,
+ * `parentId = nearest FloatingNodeContext`). This helper + {@link resolveFloatingTree} own tree
+ * selection. Parent assignment is resolved at runtime via the `RdxFloatingRegistrationContext` handle
+ * (`parentReg.node()` in `effect()`). In particular `{ kind: 'root' }` is **not** tree isolation — it
+ * sets `parent = null` **within the same tree**. A genuinely separate tree is supplied explicitly via
+ * `resolveFloatingTree(externalTree)`.
+ */
+function provideFloatingTree() {
+    return {
+        provide: RDX_FLOATING_TREE,
+        useFactory: () => inject(RDX_FLOATING_TREE, { optional: true, skipSelf: true }) ?? new RdxFloatingTree()
+    };
+}
+/**
+ * Resolves **which tree** a node joins — the tree-selection contract, the Angular counterpart of Base
+ * UI's `externalTree ?? contextTree` (`FloatingTree.tsx:25`). An explicit `externalTree` wins,
+ * otherwise the nearest injected {@link RDX_FLOATING_TREE} (or `null` → the capability runs
+ * **node-optional**). Parent assignment is separate — resolved reactively via
+ * `parentReg.node()` from the {@link RDX_FLOATING_REGISTRATION} handle, not via a token.
+ *
+ * For a **detached** node registered with an explicit `{ kind: 'node', parent }` override from a sibling
+ * injector, the nearest injected tree may be absent or a *different* tree than `parent.tree` — so the
+ * caller **must** pass `externalTree = override.parent.tree` here, so the node joins its parent's tree (the
+ * cross-tree invariant then holds). Must be called in an injection context when `externalTree` is omitted.
+ */
+function resolveFloatingTree(externalTree) {
+    return externalTree ?? inject(RDX_FLOATING_TREE, { optional: true });
+}
+/**
+ * The shared per-popup {@link RdxFloatingRootContext} — the Angular counterpart of Base UI's
+ * `FloatingRootContext`, created by `useFloatingRootContext` at the **primitive root** and **received**
+ * by `useDismiss` / `FloatingFocusManager` (they never create their own). Mirroring that: a primitive
+ * root (Dialog/Popover/Menu/…) creates **one** context and provides it here; the dismissal capability
+ * (ADR 0015) and the focus manager (ADR 0017) read the **same** context, so `open`, `triggers`, and the
+ * elements are never split across mechanisms.
+ *
+ * Optional: a **standalone** `rdxDismissableLayer` (no enclosing primitive root) has none, and
+ * {@link injectFloatingRootContext} creates a fallback for that case only.
+ */
+const RDX_FLOATING_ROOT_CONTEXT = new InjectionToken('RdxFloatingRootContext');
+/** Provides the shared {@link RdxFloatingRootContext} for a primitive root's subtree. */
+function provideFloatingRootContext(factory) {
+    return { provide: RDX_FLOATING_ROOT_CONTEXT, useFactory: factory };
+}
+/**
+ * Returns the shared {@link RdxFloatingRootContext} provided by an enclosing primitive root, or creates
+ * a **standalone fallback** via `fallback()` when none is provided (a bare `rdxDismissableLayer`). Must be
+ * called in an injection context.
+ */
+function injectFloatingRootContext(fallback) {
+    return inject(RDX_FLOATING_ROOT_CONTEXT, { optional: true }) ?? fallback();
+}
+
+/**
+ * Registers a {@link RdxFloatingNode} into the shared {@link RdxFloatingTree} for its DI subtree and
+ * propagates the registration handle to descendants — the reusable Angular counterpart of mounting a
+ * Base UI `<FloatingNode>` (ADR 0015 §1, Phase 1). It is the **single** place that runs the handle
+ * pattern; the dismissal capability (ADR 0015) and the focus manager (ADR 0017) **consume** the node /
+ * context / tree it registers, they do not re-implement registration.
+ *
+ * **What it owns vs. what it reads.** It provides its own {@link RdxFloatingRegistrationContext} (so
+ * descendants resolve it with `skipSelf`) and registers/unregisters a node reactively. It does **not**
+ * create the tree or the root context — a coordination-boundary primitive root supplies those
+ * (`provideFloatingTree()` inherit-or-create + `provideFloatingRootContext()`); this directive injects
+ * them. With **no** enclosing tree it runs **node-optional** (`status() === 'detached'`, `node() ===
+ * null`), reading its context directly — the standalone `rdxDismissableLayer` case.
+ *
+ * **Resolution (per {@link RdxFloatingParentOverride}).** Only an `inherit` node depends on the DI
+ * parent, so only it waits on a `pending` parent; `root` / `node` overrides are independent and register
+ * immediately. The node carries the injected {@link RDX_FLOATING_ROOT_CONTEXT} (or `null` for a
+ * contextless intermediate). All teardown (re-resolution **and** destroy) unregisters the node and
+ * reverts the handle.
+ */
+class RdxFloatingNodeRegistration {
+    constructor() {
+        /** Explicit tree for detached sibling composition — Base UI's `externalTree`. */
+        this.externalTree = input(null, ...(ngDevMode ? [{ debugName: "externalTree" }] : /* istanbul ignore next */ []));
+        /** How this node's logical parent is resolved. Defaults to `inherit` (nearest DI ancestor). */
+        this.parentOverride = input({ kind: 'inherit' }, ...(ngDevMode ? [{ debugName: "parentOverride" }] : /* istanbul ignore next */ []));
+        /** Own handle — the WRITER side (concrete class); this directive is the only writer. */
+        this.selfReg = inject(RdxFloatingRegistrationContext);
+        /** Nearest ancestor handle — the READER side (reader-typed token), or `null` at the top. */
+        this.parentReg = inject(RDX_FLOATING_REGISTRATION, { optional: true, skipSelf: true });
+        /** The enclosing tree, if a coordination boundary provided one (else node-optional). */
+        this.ambientTree = inject(RDX_FLOATING_TREE, { optional: true });
+        /** This node's per-popup context, or `null` for a contextless intermediate node. */
+        this.rootContext = inject(RDX_FLOATING_ROOT_CONTEXT, { optional: true });
+        this.nodeId = injectId('rdx-floating-node-');
+        /** This directive's node once registered (`null` while `pending` / `detached`). */
+        this.node = this.selfReg.node;
+        /** Lifecycle phase of this directive's registration (`pending` | `detached` | `registered`). */
+        this.status = this.selfReg.status;
+        /** The tree this node joined (`null` until `registered`). */
+        this.tree = this.selfReg.tree;
+        effect((onCleanup) => {
+            const override = this.parentOverride();
+            // Only `inherit` depends on the DI parent → only it waits on a `pending` parent (reading
+            // status() subscribes us, so we re-run when the parent resolves). `root` / `node` overrides
+            // are independent of the DI ancestor and register immediately.
+            if (override.kind === 'inherit' && this.parentReg?.status() === 'pending') {
+                return;
+            }
+            // Logical parent: explicit for `node`, `null` for `root`, the DI parent for `inherit`
+            // (a `detached` parent reads `null` → this node becomes a root within its tree).
+            const parentNode = override.kind === 'node'
+                ? override.parent
+                : override.kind === 'root'
+                    ? null
+                    : (this.parentReg?.node() ?? null);
+            // Tree selection (resolveFloatingTree's logic, replicated because inject() is illegal inside
+            // effect()): a `node` override must join its parent's tree.
+            const resolvedTree = (override.kind === 'node' ? override.parent.tree : null) ??
+                this.externalTree() ??
+                this.parentReg?.tree() ??
+                this.ambientTree;
+            if (!resolvedTree) {
+                this.selfReg.markDetached(); // node-optional: resolved, but no tree → no node
+                return;
+            }
+            const node = resolvedTree.register({
+                id: this.nodeId,
+                parent: parentNode,
+                context: this.rootContext
+            });
+            this.selfReg.register(resolvedTree, node);
+            onCleanup(() => {
+                resolvedTree.unregister(node);
+                this.selfReg.clear(); // transient: back to `pending` until the effect re-resolves
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFloatingNodeRegistration, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxFloatingNodeRegistration, isStandalone: true, selector: "[rdxFloatingNode]", inputs: { externalTree: { classPropertyName: "externalTree", publicName: "externalTree", isSignal: true, isRequired: false, transformFunction: null }, parentOverride: { classPropertyName: "parentOverride", publicName: "parentOverride", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideFloatingRegistration()], exportAs: ["rdxFloatingNode"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFloatingNodeRegistration, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxFloatingNode]',
+                    exportAs: 'rdxFloatingNode',
+                    providers: [provideFloatingRegistration()]
+                }]
+        }], ctorParameters: () => [], propDecorators: { externalTree: [{ type: i0.Input, args: [{ isSignal: true, alias: "externalTree", required: false }] }], parentOverride: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentOverride", required: false }] }] } });
+
+/**
+ * Per-popup store of active **trigger** elements — the Angular counterpart of Base UI's
+ * `triggerElements` (`PopupTriggerMap`) on each `FloatingRootStore`. One registry lives on each
+ * {@link RdxFloatingRootContext} (NOT on the shared tree, and NOT on the node — the context can exist
+ * without a node, e.g. the node-optional Navigation Menu case). Scoping it per-context is what keeps
+ * one independent popup's trigger from counting as inside-content for an unrelated popup.
+ *
+ * Within its context it is read by **both** the dismissal engine (ADR 0015 — outside-press / focus-out
+ * containment) and the focus manager (ADR 0017 — inside-element checks), so the two never drift into
+ * different inside-element sets (ADR 0015 §1 pillar 3, §2). A trigger is plain inside-content: it has
+ * **no** floating node and **no** parent — only its membership is stored here.
+ *
+ * Matching mirrors Base UI's `isTargetInsideEnabledTrigger`: a target counts when it is exactly a
+ * registered element ({@link hasElement}) **or** a descendant of one ({@link hasMatchingElement}).
+ * Membership is by **reference** (`Set.has` / `Node.contains`), so it stays correct **cross-realm** for
+ * elements from another `Window` / iframe — where `target instanceof Element` against the local realm
+ * would wrongly return `false`.
+ */
+class RdxTriggerRegistry {
+    constructor() {
+        this.elements = new Set();
+    }
+    /** Registers `element` as a trigger. Idempotent. */
+    add(element) {
+        this.elements.add(element);
+    }
+    /** Removes `element` from the registry. */
+    delete(element) {
+        this.elements.delete(element);
+    }
+    /**
+     * Exact membership — Base UI `triggerElements.hasElement(target)`. Uses reference identity
+     * (`Set.has`), **not** `instanceof Element`, so a trigger from another realm/iframe still matches.
+     */
+    hasElement(target) {
+        return target !== null && this.elements.has(target);
+    }
+    /**
+     * Ancestor match — Base UI `hasMatchingElement((t) => contains(t, target))`: `true` when any
+     * registered trigger contains `target`. Catches a press/focus landing on a child of the trigger.
+     */
+    hasMatchingElement(target) {
+        if (!target) {
+            return false;
+        }
+        for (const element of this.elements) {
+            if (element.contains(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** `true` when `target` is a registered trigger or lives inside one. */
+    contains(target) {
+        if (this.hasElement(target)) {
+            return true;
+        }
+        // `hasMatchingElement` calls `Node.contains()`, which requires a real `Node`. An `EventTarget`
+        // that is not a `Node` (e.g. `window`, a `MediaQueryList`) reaches here from a DOM event target
+        // and would make `contains()` throw — so duck-type `nodeType` and skip the ancestor match
+        // otherwise (a non-`Node` can never be a descendant of a registered element anyway).
+        return this.hasMatchingElement(isNode(target) ? target : null);
+    }
+}
+/** Narrows an `EventTarget` to `Node` by duck-typing `nodeType` (cross-realm-safe; no `instanceof`). */
+function isNode(target) {
+    return target !== null && typeof target.nodeType === 'number';
+}
+
+const DOCS = 'utils/floating-tree';
+/**
+ * The per-popup **root context / store** — the Angular counterpart of Base UI's `FloatingRootStore`
+ * (`FloatingRootContext`). It is a **separate entity from {@link RdxFloatingNode}** (which is only
+ * `id` + `parent` + a context ref), mirroring Base UI: the node carries tree membership, the root
+ * context carries the popup's `open`, elements, and trigger registry.
+ *
+ * Crucially it can exist **without** a node — the `getEmptyRootContext()` analog ({@link
+ * createFloatingRootContext}) — which is what lets a **node-optional** capability (Navigation Menu,
+ * ADR 0015 §1 / ADR 0017 #12) still read `open()`, `triggers`, and the elements while its tree node is
+ * temporarily absent. A dismissal/focus capability therefore references a root context **mandatorily**
+ * and a node **optionally**.
+ *
+ * `floatingElement` / `referenceElement` are exposed read-only and mutated **only** through the
+ * validated setters, so a consumer cannot bypass the owner-`Document` invariant with a raw assignment.
+ */
+class RdxFloatingRootContext {
+    constructor(init) {
+        /** Per-popup trigger registry (Base UI `triggerElements`), read by both dismissal and focus. */
+        this.triggers = new RdxTriggerRegistry();
+        /**
+         * Per-popup typed event channel (Base UI `FloatingRootStore.events`). Scoped to this popup,
+         * so open-change events carry no cross-popup bleed. Use `events.emit('openchange', …)` when
+         * the popup's `open` state changes; dismissal / focus manager subscribe here, not on the tree.
+         */
+        this.events = createFloatingEvents();
+        this.floatingElementRef = null;
+        this.referenceElementRef = null;
+        this.floatingElementsRef = new Set();
+        this.ownerDocument = init.ownerDocument;
+        this.open = init.open ?? (() => false);
+        if (init.floatingElement !== undefined) {
+            this.setFloatingElement(init.floatingElement);
+        }
+        if (init.referenceElement !== undefined) {
+            this.setReferenceElement(init.referenceElement);
+        }
+    }
+    /** The floating (popup) element, once it renders. `null` while mounted-but-not-yet-rendered. */
+    get floatingElement() {
+        return this.floatingElementRef;
+    }
+    /** The reference (anchor / trigger) element the popup is positioned against. */
+    get referenceElement() {
+        return this.referenceElementRef;
+    }
+    /**
+     * **All** of this layer's own root elements — the popup plus any extra roots a primitive owns (e.g.
+     * a Dialog backdrop relocated as a separate body sibling). This is DOM-footprint bookkeeping for
+     * primitive-specific checks; `markOthers` keep-sets are intentionally narrower and do not include
+     * sibling roots such as backdrops. Distinct from {@link floatingElement} (the single popup, used for
+     * press / focus containment).
+     */
+    get floatingElements() {
+        return this.floatingElementsRef;
+    }
+    /** Assigns the floating (popup) element, validating it shares this context's `ownerDocument`. */
+    setFloatingElement(element) {
+        this.assertSameDocument(element);
+        if (this.floatingElementRef) {
+            this.floatingElementsRef.delete(this.floatingElementRef);
+        }
+        this.floatingElementRef = element;
+        if (element) {
+            this.floatingElementsRef.add(element);
+        }
+    }
+    /** Registers an additional owned root element (e.g. a backdrop) into {@link floatingElements}. */
+    addFloatingElement(element) {
+        this.assertSameDocument(element);
+        this.floatingElementsRef.add(element);
+    }
+    /** Removes a previously {@link addFloatingElement | added} owned root element. */
+    removeFloatingElement(element) {
+        this.floatingElementsRef.delete(element);
+    }
+    /** Assigns the reference element, validating it shares this context's `ownerDocument`. */
+    setReferenceElement(element) {
+        this.assertSameDocument(element);
+        this.referenceElementRef = element;
+    }
+    assertSameDocument(element) {
+        if (isDevMode() && element !== null && element.ownerDocument !== this.ownerDocument) {
+            rdxDevError('floating/cross-document-element', "A floating element must share its root context's ownerDocument.", DOCS);
+        }
+    }
+}
+/**
+ * Creates a standalone {@link RdxFloatingRootContext} **without** a tree node — the Angular counterpart
+ * of Base UI's `getEmptyRootContext()`. Use it for a node-optional capability that needs a root context
+ * before (or without) registering a floating node.
+ */
+function createFloatingRootContext(init) {
+    return new RdxFloatingRootContext(init);
+}
+
+/** Default marker attribute on the imperatively-created internal backdrop element. */
+const RDX_INTERNAL_BACKDROP_ATTR = 'data-rdx-internal-backdrop';
+/** Base UI's clip-path that cuts a rectangular hole at `rect` out of a full-viewport element. */
+function cutoutClipPath(rect) {
+    return (`polygon(0% 0%,100% 0%,100% 100%,0% 100%,0% 0%,` +
+        `${rect.left}px ${rect.top}px,${rect.left}px ${rect.bottom}px,` +
+        `${rect.right}px ${rect.bottom}px,${rect.right}px ${rect.top}px,${rect.left}px ${rect.top}px)`);
+}
+/**
+ * Renders Base UI's **internal backdrop** for a modal floating popup: a full-viewport element that
+ * intercepts background pointer events (so the page behind the popup is non-interactive) **and** is
+ * itself the outside-press target — clicking it lets the dismissal capability close the popup. This is
+ * why a plain `inert` pass on outside elements is not enough: an inert element dispatches no pointer
+ * event, so the popup could never close on an outside click. An optional clip-path cutout keeps the
+ * trigger (or another region) clickable.
+ *
+ * Inserted as a **sibling before the positioner** — a sibling, not a child: a `position: fixed` element
+ * inside a transformed positioner would be clipped to the positioner's box, not the viewport. The
+ * positioner's own stacking (its `z-index`) keeps the popup above the backdrop.
+ *
+ * Call from the positioner directive inside `afterNextRender` (so the structural portal has already
+ * relocated the positioner into its container).
+ */
+function setupInternalBackdrop(positioner, injector, options) {
+    const ownerDocument = positioner.ownerDocument;
+    const marker = options.marker ?? RDX_INTERNAL_BACKDROP_ATTR;
+    let backdrop = null;
+    const remove = () => {
+        backdrop?.remove();
+        backdrop = null;
+    };
+    const ref = effect(() => {
+        const open = options.isOpen();
+        const render = options.shouldRender();
+        if (render && !backdrop) {
+            backdrop = ownerDocument.createElement('div');
+            backdrop.setAttribute('role', 'presentation');
+            backdrop.setAttribute(marker, '');
+            backdrop.style.position = 'fixed';
+            backdrop.style.inset = '0px';
+            backdrop.style.userSelect = 'none';
+            backdrop.style.webkitUserSelect = 'none';
+            const cutout = options.cutout?.() ?? null;
+            if (cutout) {
+                backdrop.style.clipPath = cutoutClipPath(cutout.getBoundingClientRect());
+            }
+            positioner.parentElement?.insertBefore(backdrop, positioner);
+        }
+        else if (!render) {
+            remove();
+        }
+        if (backdrop) {
+            backdrop.style.pointerEvents = options.passThrough?.() ? 'none' : '';
+            // Clickable (the outside-press target) while open; inert during the closed-but-mounted
+            // exit window so a stray click on the fading backdrop can't fire.
+            if (open) {
+                backdrop.removeAttribute('inert');
+            }
+            else {
+                backdrop.setAttribute('inert', '');
+            }
+        }
+    }, { ...(ngDevMode ? { debugName: "ref" } : /* istanbul ignore next */ {}), injector });
+    injector.get(DestroyRef).onDestroy(() => {
+        ref.destroy();
+        remove();
+    });
+}
+
 function injectDocument() {
     return inject(DOCUMENT);
 }
@@ -1947,8 +2962,14 @@ function elementSize({ elementRef, injector }) {
     return result.asReadonly();
 }
 
-function getActiveElement() {
-    let activeElement = document.activeElement;
+/**
+ * The deepest active element, descending into open shadow roots. Pass a specific `root`
+ * (`Document` or `ShadowRoot`) to read focus in that document — defaults to the global `document`
+ * (backward compatible). A focus scope passes its host's `ownerDocument` so it stays correct across
+ * iframes / multi-document environments.
+ */
+function getActiveElement(root = document) {
+    let activeElement = root.activeElement;
     if (activeElement == null) {
         return null;
     }
@@ -1982,79 +3003,339 @@ function resizeEffect(options) {
     }, { injector: options.injector });
 }
 
+/** Marker attribute set on `<html>` while scroll is locked (a strategy-independent test/CSS hook). */
+const RDX_SCROLL_LOCKED_ATTR = 'data-rdx-scroll-locked';
+// ── Small DOM / platform helpers (inlined — we deliberately do NOT depend on `@floating-ui/utils`) ──
 /**
- * Process-wide ownership of the document scroller's overflow while one or more overlays lock
- * scrolling.
- *
- * A single shared counter across every primitive that locks scroll is essential: with separate
- * per-primitive counters, a popover and a dialog open at the same time would each capture the
- * other's already-locked state as the "original" and restore it on close, leaving the page
- * permanently unscrollable.
+ * Floating UI's `isOverflowElement`: whether `element` is itself a scroll container (its computed
+ * overflow is anything other than `visible`). Used to decide whether `<html>` or `<body>` is the page
+ * scroller — a site may set `overflow-y: scroll` on `<html>` (as Storybook does), in which case a lock
+ * on `<body>` alone has no effect.
  */
-let original = null;
-let scrollLockCount = 0;
+function isOverflowElement(element) {
+    const win = element.ownerDocument.defaultView;
+    if (!win) {
+        return false;
+    }
+    const { overflow, overflowX, overflowY, display } = win.getComputedStyle(element);
+    return (/auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) &&
+        !['inline', 'contents'].includes(display));
+}
 /**
- * Locks page scrolling while `active()` is `true`, and restores the original state when it becomes
- * `false` or the calling context is destroyed.
- *
- * Locks **both** `<body>` and `<html>`: a `body { overflow: hidden }` lock alone does *not* stop the
- * page when `<html>` is the scroller (e.g. a global `overflow-y: scroll`, as Storybook sets), because
- * body-overflow only propagates to the viewport when `<html>`'s overflow is `visible`. The width of
- * the removed scrollbar is added as `padding-right` on `<html>` so the page doesn't shift.
- *
- * Lock ownership is shared across all callers via a single module-level counter, so nested or
- * concurrent overlays compose correctly. Must be called in an injection context.
+ * WebKit (Safari / any iOS browser) UA check — needs the `Safari` token and excludes desktop Blink
+ * (Chrome / Edge / Android), so jsdom (`AppleWebKit … jsdom`, no `Safari`) is correctly **not** WebKit.
+ * Mirrors the same helper in the dismissal capability; only WebKit needs the pinch-zoom bail-out.
+ */
+function isWebKit(win) {
+    const ua = win.navigator.userAgent;
+    return /AppleWebKit/i.test(ua) && /Safari/i.test(ua) && !/Chrome|Chromium|Edg|Android/i.test(ua);
+}
+/** iOS / iPadOS detection (iPadOS 13+ reports as Mac, so also accept touch-capable `MacIntel`). */
+function isIOS(win) {
+    const nav = win.navigator;
+    return /iP(ad|hone|od)/.test(nav.userAgent) || (nav.platform === 'MacIntel' && nav.maxTouchPoints > 1);
+}
+/** Whether the document currently has **inset** (space-consuming) scrollbars rather than overlay ones. */
+function hasInsetScrollbars(doc) {
+    const win = doc.defaultView;
+    return win ? win.innerWidth - doc.documentElement.clientWidth > 0 : false;
+}
+/**
+ * Feature-detects `scrollbar-gutter: stable` by measuring whether toggling overflow shifts the scroller's
+ * box. When supported, the lock can reserve the gutter with `scrollbar-gutter: stable` instead of the
+ * `body { position: relative; width: calc(...) }` compensation. Restores everything it touches.
+ */
+function supportsStableScrollbarGutter(doc) {
+    const win = doc.defaultView;
+    if (!win || typeof CSS === 'undefined' || !CSS.supports || !CSS.supports('scrollbar-gutter', 'stable')) {
+        return false;
+    }
+    const html = doc.documentElement;
+    const scrollContainer = isOverflowElement(html) ? html : doc.body;
+    const originalOverflowY = scrollContainer.style.overflowY;
+    const originalGutter = html.style.scrollbarGutter;
+    html.style.scrollbarGutter = 'stable';
+    scrollContainer.style.overflowY = 'scroll';
+    const before = scrollContainer.offsetWidth;
+    scrollContainer.style.overflowY = 'hidden';
+    const after = scrollContainer.offsetWidth;
+    scrollContainer.style.overflowY = originalOverflowY;
+    html.style.scrollbarGutter = originalGutter;
+    return before === after;
+}
+// ── The two Base UI locking strategies (each returns its own restore callback) ──
+/**
+ * Overlay-scrollbar strategy (iOS, or any document without inset scrollbars): scrollbars float over the
+ * content and take no layout space, so a plain `overflow: hidden` on the scroller suffices — no gutter
+ * compensation, no scroll-position juggling needed.
+ */
+function preventScrollOverlayScrollbars(doc) {
+    const html = doc.documentElement;
+    const elementToLock = isOverflowElement(html) ? html : doc.body;
+    const original = {
+        overflowX: elementToLock.style.overflowX,
+        overflowY: elementToLock.style.overflowY
+    };
+    elementToLock.style.overflowX = 'hidden';
+    elementToLock.style.overflowY = 'hidden';
+    return () => {
+        elementToLock.style.overflowX = original.overflowX;
+        elementToLock.style.overflowY = original.overflowY;
+    };
+}
+/**
+ * Inset-scrollbar strategy (desktop with space-consuming scrollbars). Faithful port of Base UI's
+ * `preventScrollInsetScrollbars`: preserves the scroll position by parking it on `<body>` (made
+ * `position: relative` with a viewport-sized box), reserves the scrollbar gutter (via
+ * `scrollbar-gutter: stable` when supported, else a `width/height: calc(...)` compensation) so nothing
+ * shifts, bails out entirely during a Safari pinch-zoom, and re-locks on resize. All snapshot state is
+ * **closure-local** (not module-global as in Base UI), so concurrent locks in different documents never
+ * clobber each other's saved styles.
  */
-function useScrollLock(active) {
-    const document = inject(DOCUMENT$1);
-    let isLocked = false;
-    const lock = () => {
-        if (isLocked) {
+function preventScrollInsetScrollbars(doc) {
+    const html = doc.documentElement;
+    const body = doc.body;
+    const win = doc.defaultView;
+    if (!win) {
+        return () => { };
+    }
+    // Pinch-zoom in Safari causes a shift — just don't lock while zoomed.
+    if (isWebKit(win) && (win.visualViewport?.scale ?? 1) !== 1) {
+        return () => { };
+    }
+    let scrollTop = 0;
+    let scrollLeft = 0;
+    let updateGutterOnly = false;
+    let originalHtmlStyles = {};
+    let originalBodyStyles = {};
+    let originalHtmlScrollBehavior = '';
+    let resizeFrame = 0;
+    const lockScroll = () => {
+        // ─── DOM reads ───
+        const htmlStyles = win.getComputedStyle(html);
+        const bodyStyles = win.getComputedStyle(body);
+        const hasBothEdges = (htmlStyles.scrollbarGutter || '').includes('both-edges');
+        const scrollbarGutterValue = hasBothEdges ? 'stable both-edges' : 'stable';
+        scrollTop = html.scrollTop;
+        scrollLeft = html.scrollLeft;
+        originalHtmlStyles = {
+            scrollbarGutter: html.style.scrollbarGutter,
+            overflowY: html.style.overflowY,
+            overflowX: html.style.overflowX
+        };
+        originalHtmlScrollBehavior = html.style.scrollBehavior;
+        originalBodyStyles = {
+            position: body.style.position,
+            height: body.style.height,
+            width: body.style.width,
+            boxSizing: body.style.boxSizing,
+            overflowY: body.style.overflowY,
+            overflowX: body.style.overflowX,
+            scrollBehavior: body.style.scrollBehavior
+        };
+        const isScrollableY = html.scrollHeight > html.clientHeight;
+        const isScrollableX = html.scrollWidth > html.clientWidth;
+        const hasConstantOverflowY = htmlStyles.overflowY === 'scroll' || bodyStyles.overflowY === 'scroll';
+        const hasConstantOverflowX = htmlStyles.overflowX === 'scroll' || bodyStyles.overflowX === 'scroll';
+        // Scrollbar size (negative in Firefox, so clamp). Compensated below so nothing shifts.
+        const scrollbarWidth = Math.max(0, win.innerWidth - body.clientWidth);
+        const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
+        const marginY = (parseFloat(bodyStyles.marginTop) || 0) + (parseFloat(bodyStyles.marginBottom) || 0);
+        const marginX = (parseFloat(bodyStyles.marginLeft) || 0) + (parseFloat(bodyStyles.marginRight) || 0);
+        const elementToLock = isOverflowElement(html) ? html : body;
+        updateGutterOnly = supportsStableScrollbarGutter(doc);
+        // ─── DOM writes (do not read the DOM past here) ───
+        if (updateGutterOnly) {
+            html.style.scrollbarGutter = scrollbarGutterValue;
+            elementToLock.style.overflowY = 'hidden';
+            elementToLock.style.overflowX = 'hidden';
             return;
         }
-        if (scrollLockCount === 0) {
-            const html = document.documentElement;
-            const body = document.body;
-            const win = document.defaultView;
-            const scrollbarWidth = win ? Math.max(0, win.innerWidth - html.clientWidth) : 0;
-            original = {
-                bodyOverflow: body.style.overflow,
-                htmlOverflow: html.style.overflow,
-                htmlPaddingRight: html.style.paddingRight
-            };
-            body.style.overflow = 'hidden';
-            html.style.overflow = 'hidden';
-            if (scrollbarWidth > 0) {
-                const currentPadding = win ? parseFloat(win.getComputedStyle(html).paddingRight) || 0 : 0;
-                html.style.paddingRight = `${currentPadding + scrollbarWidth}px`;
-            }
+        Object.assign(html.style, {
+            scrollbarGutter: scrollbarGutterValue,
+            overflowY: 'hidden',
+            overflowX: 'hidden'
+        });
+        if (isScrollableY || hasConstantOverflowY) {
+            html.style.overflowY = 'scroll';
+        }
+        if (isScrollableX || hasConstantOverflowX) {
+            html.style.overflowX = 'scroll';
+        }
+        Object.assign(body.style, {
+            position: 'relative',
+            height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
+            width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
+            boxSizing: 'border-box',
+            // Set the long-hands (not the `overflow` short-hand) so the snapshot — which captures
+            // `overflowY`/`overflowX` — restores symmetrically (a short-hand here would leave a stale
+            // `overflow` declaration when only the long-hands are reset).
+            overflowY: 'hidden',
+            overflowX: 'hidden',
+            scrollBehavior: 'unset'
+        });
+        body.scrollTop = scrollTop;
+        body.scrollLeft = scrollLeft;
+        html.style.scrollBehavior = 'unset';
+    };
+    const cleanup = () => {
+        Object.assign(html.style, originalHtmlStyles);
+        Object.assign(body.style, originalBodyStyles);
+        if (!updateGutterOnly) {
+            html.scrollTop = scrollTop;
+            html.scrollLeft = scrollLeft;
+            html.style.scrollBehavior = originalHtmlScrollBehavior;
         }
-        scrollLockCount++;
-        isLocked = true;
     };
-    const unlock = () => {
-        if (!isLocked) {
-            return;
+    const handleResize = () => {
+        cleanup();
+        resizeFrame = win.requestAnimationFrame(lockScroll);
+    };
+    lockScroll();
+    win.addEventListener('resize', handleResize);
+    return () => {
+        if (resizeFrame) {
+            win.cancelAnimationFrame(resizeFrame);
+        }
+        cleanup();
+        win.removeEventListener('resize', handleResize);
+    };
+}
+/**
+ * Per-`Document` scroll-lock owner — the Angular counterpart of Base UI's `ScrollLocker`, but with **all**
+ * mutable state on the instance (Base UI keeps the style snapshots at module scope, which is unsafe across
+ * documents). Ref-counts concurrent locks so nested / sibling overlays compose: the first lock applies a
+ * strategy, the last release restores it. Keyed per `Document` (the {@link lockers} WeakMap) so an iframe's
+ * lock never corrupts the parent document's saved styles.
+ */
+class ScrollLocker {
+    constructor(doc) {
+        this.doc = doc;
+        this.lockCount = 0;
+        this.restore = null;
+        this.release = () => {
+            if (this.lockCount === 0) {
+                return;
+            }
+            this.lockCount -= 1;
+            if (this.lockCount === 0 && this.restore) {
+                this.restore();
+                this.restore = null;
+            }
+        };
+    }
+    /** Increments the lock count, applying the lock on the `0 → 1` edge. Returns this lock's release. */
+    acquire() {
+        this.lockCount += 1;
+        if (this.lockCount === 1 && this.restore === null) {
+            this.lock();
         }
-        scrollLockCount--;
-        isLocked = false;
-        if (scrollLockCount === 0 && original !== null) {
-            const html = document.documentElement;
-            document.body.style.overflow = original.bodyOverflow;
-            html.style.overflow = original.htmlOverflow;
-            html.style.paddingRight = original.htmlPaddingRight;
-            original = null;
+        return this.release;
+    }
+    lock() {
+        const html = this.doc.documentElement;
+        const win = this.doc.defaultView;
+        const htmlOverflowY = win ? win.getComputedStyle(html).overflowY : '';
+        // If the site author already hid overflow on `<html>`, respect it and apply no strategy.
+        if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {
+            this.restore = () => undefined;
         }
+        else {
+            const hasOverlayScrollbars = (win ? isIOS(win) : false) || !hasInsetScrollbars(this.doc);
+            const strategyRestore = hasOverlayScrollbars
+                ? preventScrollOverlayScrollbars(this.doc)
+                : preventScrollInsetScrollbars(this.doc);
+            this.restore = strategyRestore;
+        }
+        // Strategy-independent marker (set even when respecting author overflow, so the lock is observable).
+        html.setAttribute(RDX_SCROLL_LOCKED_ATTR, '');
+        const strategyRestore = this.restore;
+        this.restore = () => {
+            strategyRestore();
+            html.removeAttribute(RDX_SCROLL_LOCKED_ATTR);
+        };
+    }
+}
+const lockers = new WeakMap();
+function getLocker(doc) {
+    let locker = lockers.get(doc);
+    if (!locker) {
+        locker = new ScrollLocker(doc);
+        lockers.set(doc, locker);
+    }
+    return locker;
+}
+/**
+ * Locks page scrolling while `active()` is `true`, restoring the original state when it becomes `false`
+ * or the calling context is destroyed.
+ *
+ * This is the full Base UI `useScrollLock` behavioral set (ADR 0016 §1): it picks the **overlay** strategy
+ * (plain `overflow: hidden`) for iOS / overlay-scrollbar documents and the **inset** strategy for desktop
+ * scrollbars — the latter preserves the scroll position, reserves the scrollbar gutter (no content shift),
+ * bails out during a Safari pinch-zoom, and re-locks on resize. Locks compose across all callers in the
+ * same document via a shared per-`Document` ref count, and state is isolated per `Document` (iframe-safe).
+ * No-op on the server. Must be called in an injection context.
+ */
+function useScrollLock(active, options = {}) {
+    const injectedDocument = inject(DOCUMENT$1);
+    const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    let release = null;
+    let releaseDocument = null;
+    const releaseCurrent = () => {
+        release?.();
+        release = null;
+        releaseDocument = null;
     };
     effect(() => {
+        if (!isBrowser) {
+            return;
+        }
+        const document = options.referenceElement?.()?.ownerDocument ?? injectedDocument;
         if (active()) {
-            lock();
+            if (!release || releaseDocument !== document) {
+                releaseCurrent();
+                release = getLocker(document).acquire();
+                releaseDocument = document;
+            }
         }
-        else {
-            unlock();
+        else if (release) {
+            releaseCurrent();
         }
     });
-    inject(DestroyRef).onDestroy(unlock);
+    // Only register the DOM unlock on the browser — on the server `release` is never set.
+    if (isBrowser) {
+        inject(DestroyRef).onDestroy(releaseCurrent);
+    }
+}
+/**
+ * A touch-opened anchored popup leaves up to this much total horizontal gutter and is still treated as
+ * effectively full-width (Base UI `VIEWPORT_WIDTH_TOLERANCE_PX`): common ~10px side padding still locks,
+ * since that leaves too little outside space for a reliable swipe-to-dismiss.
+ */
+const VIEWPORT_WIDTH_TOLERANCE_PX = 20;
+/**
+ * Scroll lock for an **anchored** popup (Base UI `useAnchoredPopupScrollLock`, ADR 0016 §3). For a
+ * non-touch open it behaves exactly like {@link useScrollLock} (locks while `enabled()`). For a **touch**
+ * open it locks **only** when the popup is effectively viewport-width (`popupWidth >= viewportWidth -
+ * 20px`) — otherwise the page stays scrollable so the user can swipe outside to dismiss the popup. The
+ * width is measured off `element()`; reading `offsetWidth` forces layout, so it is accurate even before
+ * the popup is positioned (visibility does not affect layout). Must be called in an injection context.
+ */
+function useAnchoredScrollLock(enabled, options) {
+    const touchOpenShouldLock = signal(false, ...(ngDevMode ? [{ debugName: "touchOpenShouldLock" }] : /* istanbul ignore next */ []));
+    effect(() => {
+        const element = options.element();
+        if (!enabled() || !options.touchOpen() || !element) {
+            touchOpenShouldLock.set(false);
+            return;
+        }
+        const viewportWidth = element.ownerDocument.documentElement.clientWidth;
+        const popupWidth = element.offsetWidth;
+        touchOpenShouldLock.set(viewportWidth > 0 && popupWidth > 0 && popupWidth >= viewportWidth - VIEWPORT_WIDTH_TOLERANCE_PX);
+    });
+    useScrollLock(computed(() => enabled() && (!options.touchOpen() || touchOpenShouldLock())), {
+        referenceElement: options.element
+    });
 }
 
 // made by https://reka-ui.com/
@@ -2771,5 +4052,5 @@ var RdxPositionAlign;
  * Generated bundle index. Do not edit.
  */
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RdxControlValueAccessor, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, DOCS_BASE_URL, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_FLOATING_REGISTRATION, RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_TREE, RDX_INTERNAL_BACKDROP_ATTR, RDX_SCROLL_LOCKED_ATTR, RdxControlValueAccessor, RdxFloatingNode, RdxFloatingNodeRegistration, RdxFloatingRegistrationContext, RdxFloatingRootContext, RdxFloatingTree, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, RdxTriggerRegistry, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createCancelableChangeEventDetails, createContent, createContext, createFloatingEvents, createFloatingRootContext, createFormatter, createMonth, createMonths, docsUrl, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectFloatingRootContext, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideFloatingRegistration, provideFloatingRootContext, provideFloatingTree, provideToken, provideValueAccessor, rdxCheckLabelElement, rdxCheckTriggerElement, rdxDevError, rdxDevWarning, resetRdxDevWarnings, resizeEffect, resolveFloatingTree, roundToStepPrecision, segmentBuilders, setupInternalBackdrop, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useAnchoredScrollLock, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
 //# sourceMappingURL=radix-ng-primitives-core.mjs.map