@ethlete/core 5.0.0-next.35 → 5.0.0-next.37

package/fesm2022/ethlete-core.mjs

@@ -4,13 +4,9 @@ import { takeUntilDestroyed, toSignal, toObservable, outputFromObservable } from
 import { Subject, BehaviorSubject, debounceTime, combineLatest, map, merge, fromEvent, filter, tap, switchMap, startWith, of, defer, from, catchError, timer, takeUntil, pairwise, distinctUntilChanged, take, Observable, concatMap, EMPTY, concat, exhaustMap, share, isObservable, firstValueFrom, defaultIfEmpty } from 'rxjs';
 import { FormGroup, FormArray, FormControl } from '@angular/forms';
 import { SIGNAL, signalSetFn } from '@angular/core/primitives/signals';
-import { coerceElement } from '@angular/cdk/coercion';
 import { DOCUMENT as DOCUMENT$1, isPlatformBrowser } from '@angular/common';
-import { BreakpointObserver } from '@angular/cdk/layout';
 import { Router, NavigationEnd, NavigationSkipped, NavigationStart } from '@angular/router';
-import { Overlay } from '@angular/cdk/overlay';
-import { ComponentPortal } from '@angular/cdk/portal';
-import { autoUpdate, computePosition, offset, flip, size, shift, limitShift, arrow, hide } from '@floating-ui/dom';
+import { autoUpdate, offset, flip, shift, limitShift, computePosition, hide, arrow, size } from '@floating-ui/dom';
 import { Title, Meta, DomSanitizer } from '@angular/platform-browser';
 
 const ANIMATION_DEBUG_STORAGE_KEY = 'et-overlay-debug';
@@ -86,7 +82,7 @@ class AnimatableDirective {
                         }
                     }
                     else {
-                        animationDebugLog(`animatable ${el.tagName.toLowerCase()}`, `${eventType} ignored — count already 0 (start ${didEmitStart ? '' : 'not '}emitted)`);
+                        animationDebugLog(`animatable ${el.tagName.toLowerCase()}`, `${eventType} ignored - count already 0 (start ${didEmitStart ? '' : 'not '}emitted)`);
                         console.warn(`${el.tagName} received animation end/cancel event but activeAnimationCount is already 0. Start was ${didEmitStart ? '' : 'not '}emitted.`);
                     }
                     break;
@@ -126,7 +122,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
-const componentIds = new Map();
+const componentIds = /* @__PURE__ */ new Map();
 const createComponentId = (prefix) => {
     const id = componentIds.get(prefix) ?? 0;
     componentIds.set(prefix, id + 1);
@@ -135,7 +131,7 @@ const createComponentId = (prefix) => {
 let randomIdFallbackCounter = 0;
 /**
  * A unique id string. Uses `crypto.randomUUID()` when available, but falls back gracefully when it is
- * not — crucially in **insecure contexts** (a plain-HTTP page served from a LAN IP, not `localhost`),
+ * not - crucially in **insecure contexts** (a plain-HTTP page served from a LAN IP, not `localhost`),
  * where `crypto.randomUUID` is `undefined`. Calling it there throws, so anything using it during e.g.
  * an overlay/menu open would break on such hosts. Prefer this over `crypto.randomUUID()` directly.
  */
@@ -144,7 +140,7 @@ const randomId = () => {
     if (typeof cryptoObj?.randomUUID === 'function') {
         return cryptoObj.randomUUID();
     }
-    // `getRandomValues` is available even in insecure contexts — build an RFC-4122-ish v4 id from it.
+    // `getRandomValues` is available even in insecure contexts - build an RFC-4122-ish v4 id from it.
     if (typeof cryptoObj?.getRandomValues === 'function') {
         const bytes = Array.from(cryptoObj.getRandomValues(new Uint8Array(16)));
         bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40;
@@ -152,7 +148,7 @@ const randomId = () => {
         const hex = bytes.map((byte) => (byte ?? 0).toString(16).padStart(2, '0'));
         return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex.slice(8, 10).join('')}-${hex.slice(10, 16).join('')}`;
     }
-    // last resort: no Web Crypto at all — a session-unique (not cryptographic) id is enough for DOM ids
+    // last resort: no Web Crypto at all - a session-unique (not cryptographic) id is enough for DOM ids
     return `et-id-${(randomIdFallbackCounter++).toString(36)}-${Date.now().toString(36)}`;
 };
 
@@ -179,42 +175,67 @@ const createProviders = (token, factory, extraToken) => [
     { provide: token, useFactory: factory },
     ...(extraToken ? [{ provide: extraToken, useExisting: token }] : []),
 ];
-const createProvider = (factory, options) => {
+
+const defineProvider = (factory, options) => {
     const token = new InjectionToken(options?.name ?? createComponentId('provider'));
-    const provide = () => createProviders(token, factory, options?.extraInjectionToken);
-    const injectFn = createInjectFunction(token);
-    return [provide, injectFn, token];
+    return {
+        provide: () => createProviders(token, factory, options?.extraInjectionToken),
+        inject: createInjectFunction(token),
+        token,
+    };
 };
-const createRootProvider = (factory, options) => {
+/**
+ * Like {@link defineProvider}, but the factory also runs in the root injector, so `injectX()` works
+ * without anyone calling `provideX()`. `provideX()` still exists, to give a subtree its own instance.
+ */
+const defineRootProvider = (factory, options) => {
     const token = new InjectionToken(options?.name ?? createComponentId('provider'), {
         providedIn: 'root',
         factory,
     });
-    const provide = () => createProviders(token, factory, options?.extraInjectionToken);
-    const injectFn = createInjectFunction(token);
-    return [provide, injectFn, token];
+    return {
+        provide: () => createProviders(token, factory, options?.extraInjectionToken),
+        inject: createInjectFunction(token),
+        token,
+    };
 };
-const createStaticProvider = (defaultValue, options) => {
+/**
+ * Like {@link defineProvider} for a plain value rather than a factory: `provideX(override)` merges the
+ * partial override over `defaultValue`, which is how every config object in the library is shaped.
+ */
+const defineStaticProvider = (defaultValue, options) => {
     const token = new InjectionToken(options?.name ?? createComponentId('static-provider'));
-    const provide = (valueOverride) => [
-        { provide: token, useValue: maybeMergeValues(defaultValue, valueOverride) },
-        ...(options?.extraInjectionToken ? [{ provide: options.extraInjectionToken, useExisting: token }] : []),
-    ];
-    const injectFn = createInjectFunction(token);
-    return [provide, injectFn, token];
+    return {
+        provide: (valueOverride) => createValueProviders(token, defaultValue, valueOverride, options),
+        inject: createInjectFunction(token),
+        token,
+    };
 };
-const createStaticRootProvider = (defaultValue, options) => {
+/**
+ * {@link defineStaticProvider} whose default is also available in the root injector, so `injectX()`
+ * resolves to `defaultValue` in an app that never provides it.
+ */
+const defineStaticRootProvider = (defaultValue, options) => {
     const token = new InjectionToken(options?.name ?? createComponentId('static-provider'), {
         providedIn: 'root',
         factory: () => defaultValue,
     });
-    const provide = (valueOverride) => [
-        { provide: token, useValue: maybeMergeValues(defaultValue, valueOverride) },
-        ...(options?.extraInjectionToken ? [{ provide: options.extraInjectionToken, useExisting: token }] : []),
-    ];
-    const injectFn = createInjectFunction(token);
-    return [provide, injectFn, token];
+    return {
+        provide: (valueOverride) => createValueProviders(token, defaultValue, valueOverride, options),
+        inject: createInjectFunction(token),
+        token,
+    };
 };
+
+const toProvideFn = (definition) => definition.provide;
+/** The `injectX` half of a provider definition. */
+const toInjectFn = (definition) => definition.inject;
+/** The token behind a provider definition. */
+const toToken = (definition) => definition.token;
+const createValueProviders = (token, defaultValue, valueOverride, options) => [
+    { provide: token, useValue: maybeMergeValues(defaultValue, valueOverride) },
+    ...(options?.extraInjectionToken ? [{ provide: options.extraInjectionToken, useExisting: token }] : []),
+];
 const maybeMergeValues = (defaultValue, valueOverride) => {
     if (valueOverride && defaultValue && typeof defaultValue === 'object') {
         return { ...defaultValue, ...valueOverride };
@@ -222,7 +243,6 @@ const maybeMergeValues = (defaultValue, valueOverride) => {
     return valueOverride ?? defaultValue;
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const cloneFormGroup = (formGroup) => {
     const cloneLevel = (group, cloneGroup) => {
         Object.keys(group.controls).forEach((key) => {
@@ -233,7 +253,6 @@ const cloneFormGroup = (formGroup) => {
                 cloneLevel(control, cloneControl);
             }
             else if (control instanceof FormArray) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const cloneArrayControl = new FormArray([], control.validator, control.asyncValidator);
                 control.controls.forEach((control) => {
                     if (control instanceof FormGroup) {
@@ -296,7 +315,6 @@ const applyHostListeners = (listeners, options) => {
     for (const eventName in listeners) {
         const handler = listeners[eventName];
         if (handler) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             applyHostListener(eventName, handler, options);
         }
     }
@@ -389,7 +407,7 @@ const copyToClipboard = (text) => defer(() => {
     }
     if (navigator.clipboard) {
         return from(navigator.clipboard.writeText(text)).pipe(map(() => true), 
-        // The async Clipboard API can be blocked (missing permission, insecure context) — try the legacy path.
+        // The async Clipboard API can be blocked (missing permission, insecure context) - try the legacy path.
         catchError(() => of(copyToClipboardViaExecCommand(text))));
     }
     return of(copyToClipboardViaExecCommand(text));
@@ -426,7 +444,6 @@ const copyToClipboardViaExecCommand = (text) => {
     return didCopy;
 };
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-var */
 /**
  * Stolen from klona to avoid adding a dependency
@@ -455,7 +472,11 @@ const clone = (original) => {
     if (typeof original !== 'object')
         return original;
     var _og = original;
-    var i = 0, k, list, tmp, str = Object.prototype.toString.call(_og);
+    var i = 0;
+    var k;
+    var list;
+    var tmp;
+    var str = Object.prototype.toString.call(_og);
     if (str === '[object Object]') {
         tmp = Object.create(_og.__proto__ || null);
     }
@@ -487,8 +508,6 @@ const clone = (original) => {
         tmp = _og.slice(0);
     }
     else if (str.slice(-6) === 'Array]') {
-        // ArrayBuffer.isView(x)
-        // ~> `new` bcuz `Buffer.slice` => ref
         tmp = new _og.constructor(_og);
     }
     if (tmp) {
@@ -537,7 +556,9 @@ function find(iter, tar, key) {
     }
 }
 const equal = (foo, bar) => {
-    var ctor, len, tmp;
+    var ctor;
+    var len;
+    var tmp;
     if (foo === bar)
         return true;
     if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
@@ -707,7 +728,7 @@ class KeyPressManager {
     }
 }
 
-const [provideRenderer, injectRenderer] = createRootProvider(() => {
+const RENDERER_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const rendererFactory = inject(RendererFactory2);
     const renderer = rendererFactory.createRenderer(null, null);
     const addClass = (element, ...classes) => {
@@ -890,7 +911,10 @@ const [provideRenderer, injectRenderer] = createRootProvider(() => {
         renderer,
     };
 }, { name: 'Angular Renderer' });
+const provideRenderer = /* @__PURE__ */ toProvideFn(RENDERER_DEF);
+const injectRenderer = /* @__PURE__ */ toInjectFn(RENDERER_DEF);
 
+const coerceElement = (el) => (el instanceof ElementRef ? el.nativeElement : el);
 const isElementSignal = (el) => {
     if (!isSignal(el))
         return false;
@@ -1229,17 +1253,17 @@ const memoizeSignal = (factory) => {
 };
 
 /** Inject a signal containing a boolean value indicating if the viewport is xs */
-const injectIsXs = memoizeSignal(() => injectObserveBreakpoint({ max: 'xs' }));
+const injectIsXs = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ max: 'xs' }));
 /** Inject a signal containing a boolean value indicating if the viewport is sm */
-const injectIsSm = memoizeSignal(() => injectObserveBreakpoint({ min: 'sm', max: 'sm' }));
+const injectIsSm = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ min: 'sm', max: 'sm' }));
 /** Inject a signal containing a boolean value indicating if the viewport is md */
-const injectIsMd = memoizeSignal(() => injectObserveBreakpoint({ min: 'md', max: 'md' }));
+const injectIsMd = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ min: 'md', max: 'md' }));
 /** Inject a signal containing a boolean value indicating if the viewport is lg */
-const injectIsLg = memoizeSignal(() => injectObserveBreakpoint({ min: 'lg', max: 'lg' }));
+const injectIsLg = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ min: 'lg', max: 'lg' }));
 /** Inject a signal containing a boolean value indicating if the viewport is xl */
-const injectIsXl = memoizeSignal(() => injectObserveBreakpoint({ min: 'xl', max: 'xl' }));
+const injectIsXl = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ min: 'xl', max: 'xl' }));
 /** Inject a signal containing a boolean value indicating if the viewport is 2xl */
-const injectIs2Xl = memoizeSignal(() => injectObserveBreakpoint({ min: '2xl' }));
+const injectIs2Xl = /* @__PURE__ */ memoizeSignal(() => injectObserveBreakpoint({ min: '2xl' }));
 /**
  * Inject a boolean value indicating if the viewport is matching the provided options.
  * This value is not reactive. If you want to react to changes, use the {@link injectObserveBreakpoint} function instead.
@@ -1259,7 +1283,7 @@ const injectObserveBreakpoint = (options) => injectBreakpointObserver().observeB
  */
 const injectObserveMediaQuery = (mediaQuery) => injectBreakpointObserver().observeMediaQuery(mediaQuery);
 /** Inject a signal containing the current breakpoint. */
-const injectCurrentBreakpoint = memoizeSignal(() => {
+const injectCurrentBreakpoint = /* @__PURE__ */ memoizeSignal(() => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const first = BREAKPOINT_ORDER[0];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -1276,11 +1300,11 @@ const injectCurrentBreakpoint = memoizeSignal(() => {
     });
 });
 /** Inject a signal that indicates if the user is using a portrait display */
-const injectIsPortrait = memoizeSignal(() => injectObserveMediaQuery('(orientation: portrait)'));
+const injectIsPortrait = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(orientation: portrait)'));
 /** Inject a signal that indicates if the user is using a landscape display */
-const injectIsLandscape = memoizeSignal(() => injectObserveMediaQuery('(orientation: landscape)'));
+const injectIsLandscape = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(orientation: landscape)'));
 /** Inject a signal containing the current display orientation */
-const injectDisplayOrientation = memoizeSignal(() => {
+const injectDisplayOrientation = /* @__PURE__ */ memoizeSignal(() => {
     const isPortrait = injectIsPortrait();
     return computed(() => {
         if (isPortrait())
@@ -1289,11 +1313,11 @@ const injectDisplayOrientation = memoizeSignal(() => {
     });
 });
 /** Inject a signal that indicates if the device has a touch input */
-const injectHasTouchInput = memoizeSignal(() => injectObserveMediaQuery('(pointer: coarse)'));
+const injectHasTouchInput = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(pointer: coarse)'));
 /** Inject a signal that indicates if the device has a fine input (mouse or stylus)  */
-const injectHasPrecisionInput = memoizeSignal(() => injectObserveMediaQuery('(pointer: fine)'));
+const injectHasPrecisionInput = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(pointer: fine)'));
 /** Inject a signal containing the current device input type */
-const injectDeviceInputType = memoizeSignal(() => {
+const injectDeviceInputType = /* @__PURE__ */ memoizeSignal(() => {
     const isTouch = injectHasTouchInput();
     return computed(() => {
         if (isTouch())
@@ -1302,13 +1326,13 @@ const injectDeviceInputType = memoizeSignal(() => {
     });
 });
 /** Inject a signal that indicates if the user prefers reduced motion */
-const injectPrefersReducedMotion = memoizeSignal(() => injectObserveMediaQuery('(prefers-reduced-motion: reduce)'));
+const injectPrefersReducedMotion = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(prefers-reduced-motion: reduce)'));
 /** Inject a signal containing a boolean value indicating if the user can hover (eg. using a mouse) */
-const injectCanHover = memoizeSignal(() => injectObserveMediaQuery('(hover: hover)'));
+const injectCanHover = /* @__PURE__ */ memoizeSignal(() => injectObserveMediaQuery('(hover: hover)'));
 /** Inject a signal containing the viewport dimensions */
-const injectViewportDimensions = memoizeSignal(() => signalElementDimensions(createDocumentElementSignal()));
+const injectViewportDimensions = /* @__PURE__ */ memoizeSignal(() => signalElementDimensions(createDocumentElementSignal()));
 /** Inject a signal containing the scrollbar dimensions. Dimensions will be 0 if scrollbars overlap the page contents (like on mobile). */
-const injectScrollbarDimensions = memoizeSignal(() => {
+const injectScrollbarDimensions = /* @__PURE__ */ memoizeSignal(() => {
     const document = inject(DOCUMENT);
     const renderer = injectRenderer();
     const scrollbarRuler = renderer.createElement('div');
@@ -1342,7 +1366,7 @@ const injectScrollbarDimensions = memoizeSignal(() => {
  * A change that interrupts an in-flight animation continues from the current animated size, and
  * zero/pre-layout measurements are ignored. Respects `prefers-reduced-motion`.
  *
- * The animation starts synchronously inside the `ResizeObserver` callback — it runs after layout
+ * The animation starts synchronously inside the `ResizeObserver` callback - it runs after layout
  * but **before paint**, so the host never paints a frame at its new natural size. Routing the
  * resize through a signal + effect instead would apply the animation one change-detection cycle
  * (= one painted frame) late: a growing panel would flash at its final size, snap back, and only
@@ -1409,7 +1433,7 @@ const injectAnimatedBlockSize = (config) => {
         const cleanup = () => {
             // Cancelling an animation to start the next one rejects its `finished` promise, firing this
             // cleanup after a newer animation has already taken over. That newer animation owns the
-            // resizing class, so only strip it when no other animation is mid-flight — otherwise an
+            // resizing class, so only strip it when no other animation is mid-flight - otherwise an
             // interrupted resize (rapid content changes, e.g. async search typing) would un-clip the
             // scroller while it is still animating and flash a scrollbar.
             if (animation !== null && animation !== nextAnimation) {
@@ -1425,7 +1449,7 @@ const injectAnimatedBlockSize = (config) => {
         nextAnimation.finished.then(cleanup).catch(cleanup);
         animation = nextAnimation;
     };
-    // no zone/signal indirection — see the pre-paint timing note in the doc comment above
+    // no zone/signal indirection - see the pre-paint timing note in the doc comment above
     const observer = new ResizeObserver(() => {
         if (!ready)
             return;
@@ -1568,15 +1592,41 @@ const DEFAULT_VIEWPORT_CONFIG = {
         '2xl': [1536, Infinity],
     },
 };
-const [provideViewportConfig, injectViewportConfig] = createStaticRootProvider(DEFAULT_VIEWPORT_CONFIG, {
+const VIEWPORT_CONFIG_DEF = /* @__PURE__ */ defineStaticRootProvider(DEFAULT_VIEWPORT_CONFIG, {
     name: 'Viewport Config',
 });
-const [provideBreakpointObserver, injectBreakpointObserver] = createRootProvider(() => {
-    const breakpointObserver = inject(BreakpointObserver);
+const provideViewportConfig = /* @__PURE__ */ toProvideFn(VIEWPORT_CONFIG_DEF);
+const injectViewportConfig = /* @__PURE__ */ toInjectFn(VIEWPORT_CONFIG_DEF);
+const BREAKPOINT_OBSERVER_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const viewportConfig = injectViewportConfig();
-    const isMediaQueryMatched = (mediaQuery) => breakpointObserver.isMatched(mediaQuery);
+    const defaultView = inject(DOCUMENT).defaultView;
+    const matchMedia = defaultView?.matchMedia?.bind(defaultView) ?? null;
+    const queryLists = new Map();
+    const querySignals = new Map();
+    const getQueryList = (mediaQuery) => {
+        if (!matchMedia)
+            return null;
+        let queryList = queryLists.get(mediaQuery);
+        if (!queryList) {
+            queryList = matchMedia(mediaQuery);
+            queryLists.set(mediaQuery, queryList);
+        }
+        return queryList;
+    };
+    const isMediaQueryMatched = (mediaQuery) => getQueryList(mediaQuery)?.matches ?? false;
     const observeMediaQuery = (mediaQuery) => {
-        return toSignal(breakpointObserver.observe(mediaQuery).pipe(map((x) => x.matches), startWith(isMediaQueryMatched(mediaQuery))), { requireSync: true });
+        const existing = querySignals.get(mediaQuery);
+        if (existing)
+            return existing;
+        const queryList = getQueryList(mediaQuery);
+        const matches = signal(queryList?.matches ?? false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matches" }] : /* istanbul ignore next */ []));
+        // the root provider outlives every consumer, so the listener is intentionally never removed -
+        // the same query list is shared by all of them
+        queryList?.addEventListener('change', (event) => matches.set(event.matches));
+        const result = matches.asReadonly();
+        querySignals.set(mediaQuery, result);
+        return result;
     };
     const observeBreakpoint = (options) => observeMediaQuery(buildMediaQueryString(options));
     const isBreakpointMatched = (options) => isMediaQueryMatched(buildMediaQueryString(options));
@@ -1629,13 +1679,27 @@ const [provideBreakpointObserver, injectBreakpointObserver] = createRootProvider
         isMediaQueryMatched,
     };
 }, { name: 'Breakpoint Observer' });
+const provideBreakpointObserver = /* @__PURE__ */ toProvideFn(BREAKPOINT_OBSERVER_DEF);
+const injectBreakpointObserver = /* @__PURE__ */ toInjectFn(BREAKPOINT_OBSERVER_DEF);
 
-const BREAKPOINT_KEY_SET = new Set(BREAKPOINT_ORDER);
+const BREAKPOINT_KEY_SET = /* @__PURE__ */ new Set(BREAKPOINT_ORDER);
 const isBreakpointMap = (value) => {
     if (value === null || typeof value !== 'object' || Array.isArray(value))
         return false;
     const keys = Object.keys(value);
-    return keys.length > 0 && keys.every((k) => BREAKPOINT_KEY_SET.has(k));
+    if (keys.length === 0)
+        return false;
+    const invalidKeys = keys.filter((key) => !BREAKPOINT_KEY_SET.has(key));
+    if (!invalidKeys.length)
+        return true;
+    // One bad key makes the whole map inert - it stops being a breakpoint map and becomes a plain value, which
+    // for an attribute binding means `[object Object]` and no effect at all. Silent, and expensive to find.
+    if (ngDevMode && invalidKeys.length < keys.length) {
+        console.warn(`[ethlete] A breakpoint map used the unknown key(s) ${invalidKeys.map((key) => `"${key}"`).join(', ')}, so ` +
+            `the whole map was ignored. Valid keys are ${BREAKPOINT_ORDER.join(', ')} - there is no "default"; the ` +
+            'smallest breakpoint is the fallback.');
+    }
+    return false;
 };
 const resolveFromMap = (map, bp, defaultValue) => {
     const idx = BREAKPOINT_ORDER.indexOf(bp);
@@ -1654,7 +1718,6 @@ const breakpointTransformBase = (coerce) => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     let capturedDefault = undefined;
     let initialized = false;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let cachedSig = null;
     const transformFn = (value) => {
         const coerced = isBreakpointMap(value) ? value : coerce(value);
@@ -1671,13 +1734,10 @@ const breakpointTransformBase = (coerce) => {
         const bp = currentBp();
         const r = raw();
         if (!cachedSig) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const instance = injector.get(BREAKPOINT_INSTANCE_TOKEN);
             for (const key of Object.keys(instance)) {
                 const val = instance[key];
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 if (val && typeof val === 'function' && val[SIGNAL]?.transformFn === transformFn) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     cachedSig = val;
                     break;
                 }
@@ -1686,7 +1746,6 @@ const breakpointTransformBase = (coerce) => {
         if (!cachedSig || r === undefined || !isBreakpointMap(r))
             return;
         const resolved = resolveFromMap(r, bp, capturedDefault);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         untracked(() => setInputSignal(cachedSig, resolved));
     });
     return transformFn;
@@ -1812,11 +1871,12 @@ const signalElementMutations = (el, options) => {
 };
 const signalHostElementMutations = (options) => signalElementMutations(inject(ElementRef), options);
 
-const signalElementChildren = (el) => {
+const DEFAULT_CHILDREN_MUTATIONS = { childList: true, subtree: true, attributes: true };
+const signalElementChildren = (el, options) => {
     const elements = buildElementSignal(el);
     const firstEl = firstElementSignal(elements);
     const isRendered = signalIsRendered();
-    const elementMutations = signalElementMutations(elements, { childList: true, subtree: true, attributes: true });
+    const elementMutations = signalElementMutations(elements, options?.mutations ?? DEFAULT_CHILDREN_MUTATIONS);
     return computed(() => {
         if (!isRendered())
             return [];
@@ -1972,7 +2032,12 @@ const signalStyles = (el, styleMap) => {
 const signalHostStyles = (styleMap) => signalStyles(inject(ElementRef), styleMap);
 
 const elementCanScroll = (element, direction) => {
-    const el = element || document.documentElement;
+    // Omitting the element means "the document scroller". Resolved lazily and guarded so a call on the
+    // server answers "cannot scroll" instead of throwing on a missing `document`.
+    const el = element || (typeof document === 'undefined' ? null : document.documentElement);
+    if (!el) {
+        return false;
+    }
     const { scrollHeight, clientHeight, scrollWidth, clientWidth } = el;
     if (direction === 'x') {
         return scrollWidth > clientWidth;
@@ -1982,17 +2047,25 @@ const elementCanScroll = (element, direction) => {
     }
     return scrollHeight > clientHeight || scrollWidth > clientWidth;
 };
-const createViewportRect = () => ({
-    left: 0,
-    top: 0,
-    right: window.innerWidth,
-    bottom: window.innerHeight,
-    width: window.innerWidth,
-    height: window.innerHeight,
-    x: 0,
-    y: 0,
-    toJSON: () => ({}),
-});
+const createViewportRect = () => {
+    // Collapses to a zero rect where there is no window (server). `isElementVisible` never reaches the
+    // intersection math there anyway - `elementCanScroll` already reports the document as unscrollable
+    // - so the rect only has to be a valid shape.
+    const hasWindow = typeof window !== 'undefined';
+    const width = hasWindow ? window.innerWidth : 0;
+    const height = hasWindow ? window.innerHeight : 0;
+    return {
+        left: 0,
+        top: 0,
+        right: width,
+        bottom: height,
+        width,
+        height,
+        x: 0,
+        y: 0,
+        toJSON: () => ({}),
+    };
+};
 const isElementVisible = (options) => {
     const { container, element } = options;
     if (!element) {
@@ -2206,7 +2279,7 @@ const getScrollItemTarget = (entries, container, direction, scrollOrigin, axisDi
     const firstIndex = entries.indexOf(firstVisible);
     const lastIndex = entries.indexOf(lastVisible);
     const containerRect = container.getBoundingClientRect();
-    // Only a single item is visible — it must be oversized (wider/taller than the container).
+    // Only a single item is visible - it must be oversized (wider/taller than the container).
     if (firstVisible === lastVisible) {
         const itemRect = firstVisible.target.getBoundingClientRect();
         const isStartEdgeVisible = axisDirection === 'horizontal'
@@ -2445,20 +2518,21 @@ const signalElementLastScrollDirection = (el) => {
 const signalHostElementLastScrollDirection = () => signalElementLastScrollDirection(inject(ElementRef));
 
 /**
- * A signal for whether this page is the one the reader is actually looking at — `false` for a backgrounded
+ * A signal for whether this page is the one the reader is actually looking at - `false` for a backgrounded
  * tab or a minimised window.
  *
  * Not the same question as whether an element is on screen: an IntersectionObserver reports a fully visible
  * element in a background tab, because the tab's own visibility is no part of what it measures. Anything
- * that moves on its own needs to ask both, and a timer is not a substitute — browsers throttle timers in a
+ * that moves on its own needs to ask both, and a timer is not a substitute - browsers throttle timers in a
  * hidden tab rather than stopping them, so work keeps piling up out of sight.
  */
-const injectIsDocumentVisible = memoizeSignal(() => {
+const injectIsDocumentVisible = /* @__PURE__ */ memoizeSignal(() => {
     const document = inject(DOCUMENT);
     const isVisible = () => document.visibilityState === 'visible';
     return toSignal(fromEvent(document, 'visibilitychange').pipe(map(isVisible)), { initialValue: isVisible() });
 });
 
+const DEFAULT_SCROLL_STATE_MUTATIONS = { childList: true, subtree: true, attributes: true };
 const areScrollStatesEqual = (a, b) => {
     return (a.canScroll === b.canScroll &&
         a.canScrollHorizontally === b.canScrollHorizontally &&
@@ -2469,7 +2543,7 @@ const signalElementScrollState = (el, options) => {
     const elements = buildElementSignal(el);
     const observedEl = firstElementSignal(elements);
     const elementDimensions = signalElementDimensions(elements);
-    const elementMutations = signalElementMutations(elements, { childList: true, subtree: true, attributes: true });
+    const elementMutations = signalElementMutations(elements, options?.mutations ?? DEFAULT_SCROLL_STATE_MUTATIONS);
     const isRendered = signalIsRendered();
     const initialScrollPosition = options?.initialScrollPosition;
     if (initialScrollPosition) {
@@ -2583,7 +2657,6 @@ const useCursorDragScroll = (el, options) => {
     const element = firstElementSignal(elements);
     const destroyRef = inject(DestroyRef);
     const { enabled = signal(true), allowedDirection = 'both' } = options ?? {};
-    const scrollState = signalElementScrollState(elements);
     const renderer = injectRenderer();
     const isDragging = signal(false, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "isDragging" }] : /* istanbul ignore next */ []));
@@ -2596,8 +2669,13 @@ const useCursorDragScroll = (el, options) => {
     const dragAmount = signal({ x: 0, y: 0 }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "dragAmount" }] : /* istanbul ignore next */ []));
     const document = inject(DOCUMENT);
-    const canScroll = computed(() => {
-        const currentScrollState = scrollState();
+    // Only measured when the caller hasn't already: this costs a MutationObserver and a ResizeObserver.
+    const suppliedCanScroll = options?.canScroll;
+    const measuredScrollState = suppliedCanScroll ? null : signalElementScrollState(elements);
+    const measuredCanScroll = computed(() => {
+        const currentScrollState = measuredScrollState?.();
+        if (!currentScrollState)
+            return false;
         const direction = maybeSignalValue(allowedDirection);
         switch (direction) {
             case 'both':
@@ -2608,7 +2686,8 @@ const useCursorDragScroll = (el, options) => {
                 return currentScrollState.canScrollVertically;
         }
     }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "canScroll" }] : /* istanbul ignore next */ []));
+    ...(ngDevMode ? [{ debugName: "measuredCanScroll" }] : /* istanbul ignore next */ []));
+    const canScroll = suppliedCanScroll ?? measuredCanScroll;
     // Cleanup if the element the cursor drag scroll is bound to gets changed
     effect(() => {
         const { previousElement } = element();
@@ -2709,7 +2788,7 @@ const useCursorDragScroll = (el, options) => {
         dragAmount.set({ x: 0, y: 0 });
     };
     const setupDragging = (e) => {
-        // A context menu takes the pointer away without ever delivering a `mouseup` — so without it in here, a
+        // A context menu takes the pointer away without ever delivering a `mouseup` - so without it in here, a
         // right click (or a ctrl-click on a Mac, which is the primary button) leaves the drag latched on and
         // every later mouse move scrolls the container.
         const dragEnd = merge(fromEvent(document, 'mouseup'), fromEvent(document, 'contextmenu'));
@@ -2736,7 +2815,7 @@ const useCursorDragScroll = (el, options) => {
     };
 };
 
-const ET_PROPERTY_REMOVED = Symbol('ET_PROPERTY_REMOVED');
+const ET_PROPERTY_REMOVED = /* @__PURE__ */ Symbol('ET_PROPERTY_REMOVED');
 const transformOrReturn = (src, config) => {
     const transformer = config?.transform;
     if (transformer) {
@@ -2753,7 +2832,7 @@ const createInitialRoute = () => {
     return window.location.pathname + window.location.search + window.location.hash;
 };
 /** Inject the current router event */
-const injectRouterEvent = memoizeSignal(() => {
+const injectRouterEvent = /* @__PURE__ */ memoizeSignal(() => {
     const router = inject(Router);
     const initialRoute = createInitialRoute();
     return toSignal(router.events, {
@@ -2764,7 +2843,7 @@ const injectRouterEvent = memoizeSignal(() => {
  * Signal that indicates whether the router has been initialized.
  * The router is considered initialized once the first NavigationEnd event with an id different than -1 has been emitted.
  */
-const injectIsRouterInitialized = memoizeSignal(() => {
+const injectIsRouterInitialized = /* @__PURE__ */ memoizeSignal(() => {
     const event = injectRouterEvent();
     return computed(() => {
         const e = event();
@@ -2776,7 +2855,7 @@ const injectIsRouterInitialized = memoizeSignal(() => {
  * The url includes query params as well as the fragment. Use `injectRoute` instead if you are not intrusted in those.
  * @example "/my-page?query=1&param=true#fragment"
  */
-const injectUrl = memoizeSignal(() => {
+const injectUrl = /* @__PURE__ */ memoizeSignal(() => {
     const event = injectRouterEvent();
     const router = inject(Router);
     // Captured once for reads that happen before the router has committed any
@@ -2786,7 +2865,7 @@ const injectUrl = memoizeSignal(() => {
         // We depend on `event` and `currentNavigation` only to get re-evaluated
         // around each navigation, but we read the *committed* url straight from the
         // router. The router commits `currentUrlTree` before it activates components,
-        // so `router.url` is already correct inside a child component's constructor —
+        // so `router.url` is already correct inside a child component's constructor -
         // unlike the NavigationEnd event, which only reaches this signal *after*
         // activation.
         event();
@@ -2806,7 +2885,7 @@ const injectUrl = memoizeSignal(() => {
  * Inject the current route
  * @example "/my-page"
  */
-const injectRoute = memoizeSignal(() => {
+const injectRoute = /* @__PURE__ */ memoizeSignal(() => {
     const url = injectUrl();
     return computed(() => {
         const fullUrl = url();
@@ -2841,14 +2920,9 @@ const createRoute = (router) => {
 /**
  * Inject the complete router state. This includes the current route data, path params, query params, title and fragment.
  */
-const injectRouterState = memoizeSignal(() => {
+const injectRouterState = /* @__PURE__ */ memoizeSignal(() => {
     const event = injectRouterEvent();
     const router = inject(Router);
-    // We only depend on `event` to get re-evaluated on every router event, but we
-    // read the *committed* snapshot straight from the router. The router commits
-    // `routerState` before it activates components (and emits ActivationStart
-    // before NavigationEnd), so this is already correct inside a child component's
-    // constructor — unlike an effect, which only flushes after construction.
     return computed(() => {
         event();
         return createRouterState(router);
@@ -2917,7 +2991,7 @@ const injectPathParam = (key, config) => {
  * Inject query params that changed during navigation. Unchanged query params will be ignored.
  * Removed query params will be represented by the symbol `ET_PROPERTY_REMOVED`.
  */
-const injectQueryParamChanges = memoizeSignal(() => {
+const injectQueryParamChanges = /* @__PURE__ */ memoizeSignal(() => {
     const queryParams = injectQueryParams();
     const prevQueryParams = previousSignalValue(queryParams);
     return computed(() => {
@@ -2941,7 +3015,7 @@ const injectQueryParamChanges = memoizeSignal(() => {
  * Inject path params that changed during navigation. Unchanged path params will be ignored.
  * Removed path params will be represented by the symbol `ET_PROPERTY_REMOVED`.
  */
-const injectPathParamChanges = memoizeSignal(() => {
+const injectPathParamChanges = /* @__PURE__ */ memoizeSignal(() => {
     const pathParams = injectPathParams();
     const prevPathParams = previousSignalValue(pathParams);
     return computed(() => {
@@ -2961,22 +3035,42 @@ const injectPathParamChanges = memoizeSignal(() => {
         return changes;
     });
 });
+/**
+ * The state handed to the navigation that is currently in progress, i.e. what
+ * `router.navigate(…, { state })` passed - typed to whatever you expect.
+ *
+ * Read **synchronously**, in a constructor or a resolver, and deliberately not a signal: navigation state exists
+ * only for the duration of the navigation that carries it. By the time an effect flushed, the navigation would be
+ * over and the answer always `null`. Returns `null` when there is no navigation in flight or it carried no state -
+ * which is the normal case for a page arrived at by typing its URL, so always handle it.
+ *
+ * Use it for the things a URL should not carry: a "you were redirected because…" reason, a pre-fetched object the
+ * previous page already had, a scroll intent. Anything the page needs to survive a reload belongs in the URL.
+ *
+ * @example
+ * type CheckoutNavState = { fromCart: boolean };
+ *
+ * export class CheckoutComponent {
+ *   private navState = injectRouterNavigationState<CheckoutNavState>();
+ *
+ *   protected cameFromCart = this.navState?.fromCart ?? false;
+ * }
+ */
+const injectRouterNavigationState = () => {
+    const router = inject(Router);
+    return router.getCurrentNavigation()?.extras.state ?? null;
+};
 
-const ET_DISABLE_SCROLL_TOP = Symbol('ET_DISABLE_SCROLL_TOP');
-const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE = Symbol('ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE');
-const ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE = Symbol('ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE');
+const ET_DISABLE_SCROLL_TOP = /* @__PURE__ */ Symbol('ET_DISABLE_SCROLL_TOP');
+const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE = /* @__PURE__ */ Symbol('ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE');
+const ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE = /* @__PURE__ */ Symbol('ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE');
 const routerDisableScrollTop = (config = {}) => {
     return {
         ...(!config.asReturnRoute ? { [ET_DISABLE_SCROLL_TOP]: true } : { [ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE]: true }),
         ...(config.onPathParamChange ? { [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]: true } : {}),
     };
 };
-/**
- * Registry of "not settled yet" reporters. Lives in the root injector so a route component can
- * reach the registration created by the app level `setupScrollRestoration` call.
- * @internal
- */
-const [, injectScrollRestorationHolds] = createRootProvider(() => {
+const SCROLL_RESTORATION_HOLDS_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const holds = new Set();
     return {
         add: (isPending) => {
@@ -2992,11 +3086,17 @@ const [, injectScrollRestorationHolds] = createRootProvider(() => {
         },
     };
 }, { name: 'ScrollRestorationHolds' });
+/**
+ * Registry of "not settled yet" reporters. Lives in the root injector so a route component can
+ * reach the registration created by the app level `setupScrollRestoration` call.
+ * @internal
+ */
+const injectScrollRestorationHolds = /* @__PURE__ */ toInjectFn(SCROLL_RESTORATION_HOLDS_DEF);
 /**
  * Suspend scroll restoration while `isPending` reads `true`.
  *
  * Restoration already waits for the scroll container to grow tall enough to reach the saved offset,
- * so this is only needed when the content may take longer than `restore.timeout` to get there —
+ * so this is only needed when the content may take longer than `restore.timeout` to get there -
  * a slow list request, for instance. Registers for the lifetime of the current injection context.
  *
  * @example
@@ -3030,7 +3130,7 @@ const setupScrollRestoration = (config = {}) => {
         return el ?? document.documentElement;
     };
     // The browser restores the offset against the still-loading (much shorter) document, which is the
-    // exact problem we are solving — take it over completely.
+    // exact problem we are solving - take it over completely.
     if (restoreEnabled && 'scrollRestoration' in history) {
         history.scrollRestoration = 'manual';
     }
@@ -3069,7 +3169,7 @@ const setupScrollRestoration = (config = {}) => {
             }
             const now = Date.now();
             // A registered hold means the page knows more data is coming, so the content is expected to
-            // grow — suspend the clock instead of giving up on a still loading page.
+            // grow - suspend the clock instead of giving up on a still loading page.
             if (holds.isHeld() && now < hardDeadline) {
                 deadline = now + restoreTimeout;
             }
@@ -3082,7 +3182,7 @@ const setupScrollRestoration = (config = {}) => {
             }
             cancelPendingRestore();
         };
-        // Wait for the new route to actually render before reading any geometry — on `NavigationEnd` the
+        // Wait for the new route to actually render before reading any geometry - on `NavigationEnd` the
         // components exist but the DOM still shows the previous page, whose height would be measured
         // instead. The timeout is a safety net in case no render pass follows.
         const start = () => {
@@ -3206,7 +3306,7 @@ const createLogger = (config) => {
 };
 
 const escapeHtml = (str) => str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-/** Escapes HTML-special characters but leaves existing entity references intact — for input that
+/** Escapes HTML-special characters but leaves existing entity references intact - for input that
  *  may already contain entities (e.g. Markdown serialized from the editor's DOM, where `&` is
  *  stored as `&amp;`), where plain escaping would double-escape them. */
 const escapeHtmlPreservingEntities = (str) => str
@@ -3215,7 +3315,7 @@ const escapeHtmlPreservingEntities = (str) => str
     .replace(/>/g, '&gt;')
     .replace(/"/g, '&quot;');
 /** Rejects URL schemes that execute script when navigated. Whitespace/control characters are
- *  stripped before checking — browsers ignore them inside URLs, so `java\tscript:` would
+ *  stripped before checking - browsers ignore them inside URLs, so `java\tscript:` would
  *  otherwise slip through. */
 const isSafeUrl = (url) => 
 // eslint-disable-next-line no-control-regex -- stripping control characters is the point: browsers ignore them inside URLs
@@ -3242,7 +3342,7 @@ const parseSeparatorAligns = (line) => parseTableRow(line).map((cell) => {
 /** The GFM separator token for a column alignment. */
 const separatorFor = (align) => align === 'center' ? ':---:' : align === 'right' ? '---:' : align === 'left' ? ':---' : '---';
 const alignStyle = (align) => (align ? ` style="text-align: ${align}"` : '');
-/** Wraps `content` in an emphasis `marker`, hoisting boundary whitespace outside the delimiters —
+/** Wraps `content` in an emphasis `marker`, hoisting boundary whitespace outside the delimiters -
  *  CommonMark emphasis must not face whitespace on the inside (`** fett**` doesn't parse), and
  *  `&nbsp;` counts as whitespace there too. Whitespace-only content stays unwrapped. */
 const emphasize = (marker, content) => {
@@ -3256,9 +3356,9 @@ const makePlaceholder = (kind, idx) => `\u{E000}${kind}${idx}\u{E001}`;
 const placeholderRe = (kind) => new RegExp(`\u{E000}${kind}(\\d+)\u{E001}`, 'gu');
 const isPlaceholder = (kind, str) => new RegExp(`^\u{E000}${kind}\\d+\u{E001}$`, 'u').test(str);
 /** Tags allowed to survive inside an aligned block's raw-HTML passthrough. */
-const SAFE_INLINE_TAGS = new Set(['strong', 'em', 'b', 'i', 'del', 's', 'u', 'code', 'br']);
+const SAFE_INLINE_TAGS = /* @__PURE__ */ new Set(['strong', 'em', 'b', 'i', 'del', 's', 'u', 'code', 'br']);
 /** Reduces raw inline HTML to the editor's own vocabulary: allowed tags lose all their attributes
- *  (`<a>` keeps a safe `href`), everything else — including any event-handler attribute — is
+ *  (`<a>` keeps a safe `href`), everything else - including any event-handler attribute - is
  *  dropped, and the remaining text is escaped. */
 const sanitizeInlineHtml = (html) => {
     const kept = [];
@@ -3283,7 +3383,7 @@ const processInline = (text) => {
     });
     // "Open in new tab" links round-trip as raw HTML because Markdown has no `target` syntax. Extract
     // them before the raw-HTML escape below, keeping only a safe href, `target="_blank"` and a forced
-    // `rel="noopener noreferrer"` (any other attribute — including event handlers — is dropped); their
+    // `rel="noopener noreferrer"` (any other attribute - including event handlers - is dropped); their
     // inner markup is processed recursively. Anything else that looks like raw HTML is still escaped.
     const newTabLinks = [];
     text = text.replace(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi, (full, attrs, inner) => {
@@ -3294,11 +3394,11 @@ const processInline = (text) => {
         const anchor = `<a href="${href}" target="_blank" rel="noopener noreferrer">${processInline(inner)}</a>`;
         return makePlaceholder('NTLINK', newTabLinks.push(anchor) - 1);
     });
-    // Raw HTML in Markdown text is escaped, not rendered — the editor writes this HTML straight
+    // Raw HTML in Markdown text is escaped, not rendered - the editor writes this HTML straight
     // into the DOM via innerHTML, so anything else would let a crafted value inject markup. `<u>`
     // is the one deliberate exception: underline has no Markdown form and round-trips as raw <u>.
     text = escapeHtmlPreservingEntities(text).replace(/&lt;(\/?)u&gt;/gi, '<$1u>');
-    // Bold + italic — *** before ** before *. A delimiter flanking whitespace doesn't open/close a
+    // Bold + italic - *** before ** before *. A delimiter flanking whitespace doesn't open/close a
     // run (CommonMark's flanking rule), so literal asterisks as in `2 * 3 * 4` stay text.
     text = text.replace(/\*\*\*([^\s*](?:.*?[^\s*])?)\*\*\*/g, '<strong><em>$1</em></strong>');
     text = text.replace(/\*\*([^\s*](?:.*?[^\s*])?)\*\*/g, '<strong>$1</strong>');
@@ -3361,6 +3461,75 @@ const findListItems = (inner) => {
     }
     return items;
 };
+/** The first top-level `<blockquote>` in `html`, matched with balanced nesting. */
+const findBlockquote = (html) => {
+    const open = /<blockquote\b[^>]*>/i.exec(html);
+    if (!open)
+        return null;
+    const innerStart = open.index + open[0].length;
+    const tag = /<(\/?)blockquote\b[^>]*>/gi;
+    tag.lastIndex = innerStart;
+    let depth = 1;
+    let match;
+    while ((match = tag.exec(html))) {
+        depth += match[1] ? -1 : 1;
+        if (depth === 0) {
+            return { start: open.index, end: tag.lastIndex, inner: html.slice(innerStart, match.index) };
+        }
+    }
+    return null;
+};
+/** The lines of quoted text in a blockquote's own (non-nested) HTML, each with its `> ` prefix.
+ *  `<br>` and paragraph boundaries are the line breaks - the tag-strip would swallow them. */
+const quotedLines = (html, prefix) => {
+    const text = stripTags(html.replace(/<br\s*\/?>/gi, '\n').replace(/<\/p\s*>/gi, '\n')).trim();
+    return text ? text.split('\n').map((line) => `${prefix}${line.trim()}`) : [];
+};
+/** Serializes a blockquote's inner HTML to Markdown, one `>` per nesting level. */
+const blockquoteToMarkdown = (inner, depth) => {
+    const prefix = '> '.repeat(depth + 1);
+    const lines = [];
+    let rest = inner;
+    for (let nested = findBlockquote(rest); nested; nested = findBlockquote(rest)) {
+        lines.push(...quotedLines(rest.slice(0, nested.start), prefix));
+        lines.push(blockquoteToMarkdown(nested.inner, depth + 1));
+        rest = rest.slice(nested.end);
+    }
+    lines.push(...quotedLines(rest, prefix));
+    // An empty quote still needs its marker, or it would vanish from the value entirely.
+    return lines.length > 0 ? lines.join('\n') : prefix.trim();
+};
+/** Builds a `<blockquote>` from `> `-prefixed lines, recursing into runs of deeper (`>>`) lines. */
+const buildBlockquoteHtml = (lines) => {
+    let html = '';
+    let run = [];
+    const flushRun = () => {
+        if (run.length > 0)
+            html += run.map(processInline).join('<br>');
+        run = [];
+    };
+    for (let i = 0; i < lines.length;) {
+        const stripped = (lines[i] ?? '').replace(/^>[ \t]?/, '');
+        if (!stripped.startsWith('>')) {
+            run.push(stripped);
+            i++;
+            continue;
+        }
+        flushRun();
+        const nested = [];
+        while (i < lines.length) {
+            const line = (lines[i] ?? '').replace(/^>[ \t]?/, '');
+            if (!line.startsWith('>'))
+                break;
+            nested.push(line);
+            i++;
+        }
+        html += buildBlockquoteHtml(nested);
+    }
+    flushRun();
+    // `<br>` so an empty quote has a line box the caret can sit in (the editor writes this HTML live)
+    return `<blockquote>${html || '<br>'}</blockquote>`;
+};
 /** Serializes a list's inner HTML to Markdown, indenting nested lists two spaces per level. */
 const listToMarkdown = (inner, ordered, depth) => {
     const indent = '  '.repeat(depth);
@@ -3379,7 +3548,7 @@ const listToMarkdown = (inner, ordered, depth) => {
     })
         .join('\n');
 };
-/** Parses list lines into (indent-level, ordered, text) — two leading spaces per nesting level. */
+/** Parses list lines into (indent-level, ordered, text) - two leading spaces per nesting level. */
 const parseListLines = (lines) => lines
     .map((line) => {
     const match = /^(\s*)([-*+]|\d+\.)\s+(.*)$/.exec(line);
@@ -3453,7 +3622,7 @@ const markdownToHtml = (markdown) => {
         // Horizontal rule
         if (/^(---|\*\*\*|___)\s*$/.test(trimmed))
             return '<hr>';
-        // Table (GFM) — column alignment from the separator line lands as text-align on every cell
+        // Table (GFM) - column alignment from the separator line lands as text-align on every cell
         const tableLines = trimmed.split('\n');
         if (tableLines.length >= 2 && /\|/.test(tableLines[0] ?? '') && isTableSeparatorLine(tableLines[1] ?? '')) {
             const aligns = parseSeparatorAligns(tableLines[1] ?? '');
@@ -3471,15 +3640,10 @@ const markdownToHtml = (markdown) => {
                 : '';
             return `<table>${thead}${tbody}</table>`;
         }
-        // Blockquote — each line runs through the inline pass on its own (processInline escapes raw
-        // HTML, so joining first would escape the <br> separators too)
-        if (/^> /.test(trimmed)) {
-            const content = trimmed
-                .split('\n')
-                .map((l) => processInline(l.replace(/^>\s?/, '')))
-                .join('<br>');
-            return `<blockquote>${content}</blockquote>`;
-        }
+        // Blockquote - each line runs through the inline pass on its own (processInline escapes raw
+        // HTML, so joining first would escape the <br> separators too), and a `>>` run nests
+        if (/^>/.test(trimmed))
+            return buildBlockquoteHtml(trimmed.split('\n'));
         // List (unordered/ordered, with indentation-based nesting)
         if (/^([-*+]|\d+\.)\s/.test(trimmed)) {
             const lines = parseListLines(trimmed.split('\n'));
@@ -3487,7 +3651,7 @@ const markdownToHtml = (markdown) => {
                 return buildListHtml(lines, 0, lines[0].indent).html;
             }
         }
-        // Paragraph — single newlines within a block become <br>
+        // Paragraph - single newlines within a block become <br>
         return `<p>${trimmed
             .split('\n')
             .map((l) => processInline(l))
@@ -3507,21 +3671,21 @@ const htmlToMarkdown = (html) => {
         return '';
     let md = html;
     // Aligned blocks: text-align has no Markdown form, so preserve them verbatim as native HTML (their
-    // inner markup stays HTML) and round-trip via a placeholder — extracted before the block passes
+    // inner markup stays HTML) and round-trip via a placeholder - extracted before the block passes
     // below rewrite them, restored after the final tag-strip.
     const alignedBlocks = [];
     md = md.replace(/<(p|h[1-6]|div)\b[^>]*\bstyle="[^"]*text-align[^"]*"[^>]*>[\s\S]*?<\/\1>/gi, (match) => makePlaceholder('ALIGN', alignedBlocks.push(match) - 1));
-    // Code blocks — process before inline code
+    // Code blocks - process before inline code
     md = md.replace(/<pre[^>]*><code[^>]*class="language-([^"]+)"[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, lang, code) => `\n\`\`\`${lang}\n${unescapeHtml(code.trim())}\n\`\`\`\n`);
     md = md.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, code) => `\n\`\`\`\n${unescapeHtml(code.trim())}\n\`\`\`\n`);
     md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, code) => `\n\`\`\`\n${unescapeHtml(code.trim())}\n\`\`\`\n`);
-    // Headings — keep the inner markup so the inline passes below turn any nested
+    // Headings - keep the inner markup so the inline passes below turn any nested
     // bold/italic/link/code into markdown; leftover tags are stripped at the end.
     for (let i = 6; i >= 1; i--) {
         md = md.replace(new RegExp(`<h${i}[^>]*>([\\s\\S]*?)<\\/h${i}>`, 'gi'), (_, content) => `\n${'#'.repeat(i)} ${content.trim()}\n`);
     }
     // Bold + italic (combined before individual). Boundary whitespace is hoisted out of the
-    // delimiters (emphasize) — `<strong> x</strong>` must become ` **x**`, not the invalid `** x**`.
+    // delimiters (emphasize) - `<strong> x</strong>` must become ` **x**`, not the invalid `** x**`.
     md = md.replace(/<strong[^>]*><em[^>]*>([\s\S]*?)<\/em><\/strong>/gi, (_, c) => emphasize('***', c));
     md = md.replace(/<em[^>]*><strong[^>]*>([\s\S]*?)<\/strong><\/em>/gi, (_, c) => emphasize('***', c));
     md = md.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, (_, _tag, c) => emphasize('**', c));
@@ -3530,7 +3694,7 @@ const htmlToMarkdown = (html) => {
     // Inline code
     md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, code) => `\`${unescapeHtml(code)}\``);
     // Links and images. A link with `target="_blank"` has no Markdown form, so it round-trips as raw
-    // HTML (keeping only href + target + rel) via a placeholder — like underline below; ordinary links
+    // HTML (keeping only href + target + rel) via a placeholder - like underline below; ordinary links
     // become `[text](url)`.
     const newTabLinks = [];
     md = md.replace(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi, (_, attrs, inner) => {
@@ -3544,20 +3708,17 @@ const htmlToMarkdown = (html) => {
     md = md.replace(/<img[^>]+src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
     md = md.replace(/<img[^>]+alt="([^"]*)"[^>]*src="([^"]*)"[^>]*\/?>/gi, '![$1]($2)');
     md = md.replace(/<img[^>]+src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
-    // Underline has no Markdown form — preserve it as raw <u> so it round-trips. Extract it now (its
+    // Underline has no Markdown form - preserve it as raw <u> so it round-trips. Extract it now (its
     // inner markup is already converted above) so the block passes below don't strip the tag; the
     // placeholder is restored after the final tag-strip.
     const underlines = [];
     md = md.replace(/<u[^>]*>([\s\S]*?)<\/u>/gi, (_, inner) => makePlaceholder('U', underlines.push(inner) - 1));
-    // Block quotes — <br> line breaks become one quoted line each (stripTags would swallow them)
-    md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
-        return (stripTags(content.replace(/<br\s*\/?>/gi, '\n'))
-            .trim()
-            .split('\n')
-            .map((line) => `> ${line.trim()}`)
-            .join('\n') + '\n');
-    });
-    // Lists — replace each top-level list with its recursively-serialized Markdown (handles nesting).
+    // Block quotes - replace each top-level <blockquote> with its recursively-serialized Markdown, so
+    // a quote inside a quote becomes `>>` (regex alone can't match balanced nesting).
+    for (let quote = findBlockquote(md); quote; quote = findBlockquote(md)) {
+        md = `${md.slice(0, quote.start)}\n${blockquoteToMarkdown(quote.inner, 0)}\n${md.slice(quote.end)}`;
+    }
+    // Lists - replace each top-level list with its recursively-serialized Markdown (handles nesting).
     for (let list = findList(md); list; list = findList(md)) {
         md = `${md.slice(0, list.start)}\n${listToMarkdown(list.inner, list.ordered, 0)}\n${md.slice(list.end)}`;
     }
@@ -3585,10 +3746,10 @@ const htmlToMarkdown = (html) => {
         const lines = [`| ${headerCells.join(' | ')} |`, `| ${separator} |`, ...bodyRows.map((r) => `| ${r} |`)];
         return `\n${lines.join('\n')}\n`;
     });
-    // Block elements — a <br> inside a paragraph is a soft line break; turn it into a newline before
+    // Block elements - a <br> inside a paragraph is a soft line break; turn it into a newline before
     // the tag-strip removes it, so it round-trips (a single newline within a block renders as <br>)
     md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, content) => `\n${stripTags(content.replace(/<br\s*\/?>/gi, '\n')).trim()}\n`);
-    // A <div> boundary acts as a paragraph boundary — clipboard HTML commonly uses divs as
+    // A <div> boundary acts as a paragraph boundary - clipboard HTML commonly uses divs as
     // paragraphs, and silently stripping them would merge adjacent blocks into one.
     md = md.replace(/<\/div\s*>/gi, '\n\n').replace(/<div[^>]*>/gi, '\n\n');
     md = md.replace(/<br\s*\/?>/gi, '\n');
@@ -3647,17 +3808,11 @@ class RuntimeError extends Error {
         this.code = code;
         this.data = data;
         if (data !== RUNTIME_ERROR_NO_DATA) {
-            try {
-                const _data = clone(data);
-                setTimeout(() => {
-                    console.error(_data);
-                }, 1);
-            }
-            catch {
-                setTimeout(() => {
-                    console.error(data);
-                }, 1);
-            }
+            // deferred so the error itself is logged first - consoles render the live object, so a
+            // mutation after the throw is visible in the log
+            setTimeout(() => {
+                console.error(data);
+            }, 1);
         }
     }
 }
@@ -3694,7 +3849,7 @@ const canUseSessionMemory = () => {
         if (typeof globalThis.document === 'undefined') {
             return false;
         }
-        return globalThis.sessionStorage != null;
+        return globalThis.sessionStorage !== null && globalThis.sessionStorage !== undefined;
     }
     catch {
         return false;
@@ -3763,6 +3918,8 @@ const getClientXY = (event) => {
     }
     return { clientX: event.clientX, clientY: event.clientY };
 };
+/** Trailing window over which {@link SwipeTracker.end} measures the release velocity. */
+const SWIPE_VELOCITY_WINDOW_MS = 100;
 const createSwipeTracker = (startEvent) => {
     const { clientX: originClientX, clientY: originClientY } = getClientXY(startEvent);
     const startTime = Date.now();
@@ -3770,10 +3927,25 @@ const createSwipeTracker = (startEvent) => {
     let movementY = 0;
     let isSwiping = false;
     let isScrolling = false;
+    /**
+     * Recent positions, oldest first, used to derive the release velocity. Trimmed to the trailing
+     * window plus the one sample just before it, which serves as that window's baseline.
+     */
+    let samples = [{ t: startTime, movementX: 0, movementY: 0 }];
     const update = (event) => {
         const { clientX, clientY } = getClientXY(event);
         movementX = clientX - originClientX;
         movementY = clientY - originClientY;
+        const now = Date.now();
+        samples.push({ t: now, movementX, movementY });
+        // Trim against the newest sample rather than `now + window`: `end()` measures from its own
+        // timestamp, which is never earlier, so this always keeps a superset of what it needs.
+        const cutoff = now - SWIPE_VELOCITY_WINDOW_MS;
+        let dropCount = 0;
+        while (dropCount + 1 < samples.length && samples[dropCount + 1].t < cutoff)
+            dropCount++;
+        if (dropCount)
+            samples = samples.slice(dropCount);
         const positiveMovementX = Math.abs(movementX);
         const positiveMovementY = Math.abs(movementY);
         if (!isSwiping && !isScrolling) {
@@ -3796,12 +3968,31 @@ const createSwipeTracker = (startEvent) => {
             isSwiping,
         };
     };
+    const measureReleaseVelocity = (endTime) => {
+        const windowStart = endTime - SWIPE_VELOCITY_WINDOW_MS;
+        const firstInWindow = samples.findIndex((sample) => sample.t >= windowStart);
+        // Nothing moved during the window: the pointer was held still before release, so the gesture
+        // carries no momentum no matter how fast it started out.
+        if (firstInWindow === -1)
+            return { x: 0, y: 0 };
+        const newest = samples[samples.length - 1];
+        // Measure across the window when it holds a span of its own. With a single sample in it - a
+        // pointer emitting moves slower than the window - reach back one sample for a baseline instead
+        // of reporting nothing.
+        const hasSpanInWindow = samples.length - firstInWindow >= 2;
+        const baseline = samples[hasSpanInWindow ? firstInWindow : Math.max(0, firstInWindow - 1)];
+        const elapsed = newest.t - baseline.t;
+        if (elapsed <= 0)
+            return { x: 0, y: 0 };
+        return {
+            x: ((newest.movementX - baseline.movementX) / elapsed) * 1000,
+            y: ((newest.movementY - baseline.movementY) / elapsed) * 1000,
+        };
+    };
     const end = () => {
-        const swipeTime = Math.max(1, Date.now() - startTime);
         const positiveMovementX = Math.abs(movementX);
         const positiveMovementY = Math.abs(movementY);
-        const pixelPerSecondX = (movementX / swipeTime) * 1000;
-        const pixelPerSecondY = (movementY / swipeTime) * 1000;
+        const { x: pixelPerSecondX, y: pixelPerSecondY } = measureReleaseVelocity(Date.now());
         return {
             movementX,
             movementY,
@@ -3818,11 +4009,12 @@ const createSwipeTracker = (startEvent) => {
     const cancel = () => {
         movementX = 0;
         movementY = 0;
+        samples = [{ t: Date.now(), movementX: 0, movementY: 0 }];
     };
     return { update, end, cancel };
 };
 
-const [, injectAngularRootElement] = createRootProvider(() => {
+const ANGULAR_ROOT_ELEMENT_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const appRef = inject(ApplicationRef);
     const rootElement = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "rootElement" }] : /* istanbul ignore next */ []));
@@ -3838,8 +4030,9 @@ const [, injectAngularRootElement] = createRootProvider(() => {
     setTimeout(poll);
     return rootElement;
 });
+const injectAngularRootElement = /* @__PURE__ */ toInjectFn(ANGULAR_ROOT_ELEMENT_DEF);
 
-const [provideBoundaryElement, injectBoundaryElement, BOUNDARY_ELEMENT_TOKEN] = createProvider(() => {
+const BOUNDARY_ELEMENT_DEF = /* @__PURE__ */ defineProvider(() => {
     const hostElement = inject(ElementRef, { optional: true });
     const document = inject(DOCUMENT);
     const override = signal(null, /* @ts-ignore */
@@ -3851,8 +4044,11 @@ const [provideBoundaryElement, injectBoundaryElement, BOUNDARY_ELEMENT_TOKEN] =
         override,
     };
 }, { name: 'Boundary Element' });
+const provideBoundaryElement = /* @__PURE__ */ toProvideFn(BOUNDARY_ELEMENT_DEF);
+const injectBoundaryElement = /* @__PURE__ */ toInjectFn(BOUNDARY_ELEMENT_DEF);
+const BOUNDARY_ELEMENT_TOKEN = /* @__PURE__ */ toToken(BOUNDARY_ELEMENT_DEF);
 
-const [provideFocusVisibleTracker, injectFocusVisibleTracker, FOCUS_VISIBLE_TRACKER_TOKEN] = createRootProvider(() => {
+const FOCUS_VISIBLE_TRACKER_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const document = inject(DOCUMENT);
     const destroyRef = inject(DestroyRef);
     const isFocusVisible = signal(false, /* @ts-ignore */
@@ -3894,8 +4090,11 @@ const [provideFocusVisibleTracker, injectFocusVisibleTracker, FOCUS_VISIBLE_TRAC
         isFocusVisible: isFocusVisible.asReadonly(),
     };
 }, { name: 'Focus Visible Tracker' });
+const provideFocusVisibleTracker = /* @__PURE__ */ toProvideFn(FOCUS_VISIBLE_TRACKER_DEF);
+const injectFocusVisibleTracker = /* @__PURE__ */ toInjectFn(FOCUS_VISIBLE_TRACKER_DEF);
+const FOCUS_VISIBLE_TRACKER_TOKEN = /* @__PURE__ */ toToken(FOCUS_VISIBLE_TRACKER_DEF);
 
-const [provideLocale, injectLocale] = createRootProvider(() => {
+const LOCALE_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const currentLocale = signal('en', /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "currentLocale" }] : /* istanbul ignore next */ []));
     return {
@@ -3904,8 +4103,65 @@ const [provideLocale, injectLocale] = createRootProvider(() => {
 }, {
     name: 'Locale',
 });
+const provideLocale = /* @__PURE__ */ toProvideFn(LOCALE_DEF);
+const injectLocale = /* @__PURE__ */ toInjectFn(LOCALE_DEF);
+
+const resolveSource = (source, locale) => typeof source === 'function' ? source(locale) : source;
+/**
+ * The one mechanism for the strings a component renders or announces itself. Every domain in the UI
+ * library that has such strings exposes exactly this pair - `provide<Domain>Labels` to localize a
+ * subtree, `inject<Domain>Labels()` to read the result - so localizing an app is the same move
+ * repeated per domain rather than a different one each time.
+ *
+ * `defaults` may itself be locale-derived, for a domain that ships more than one language (the
+ * `@ethlete/query` error tables, say). Overrides are partial and layer on top of whatever the locale
+ * resolved to, so translating into a third language while keeping a shipped one as the base is the
+ * same call.
+ *
+ * The injector returns a **signal**, because both halves can change at runtime - read it in a
+ * template or computed, never destructure it once.
+ *
+ * @example
+ * export type BreadcrumbLabels = { navigation: string; overflow: string };
+ *
+ * export const DEFAULT_BREADCRUMB_LABELS: BreadcrumbLabels = {
+ *   navigation: 'Breadcrumb',
+ *   overflow: 'Show hidden levels',
+ * };
+ *
+ * const BREADCRUMB_LABELS_DEF = defineLabels<BreadcrumbLabels>('BREADCRUMB_LABELS', DEFAULT_BREADCRUMB_LABELS);
+ *
+ * export const provideBreadcrumbLabels = toProvideFn(BREADCRUMB_LABELS_DEF);
+ * export const injectBreadcrumbLabels = toInjectFn(BREADCRUMB_LABELS_DEF);
+ * export const BREADCRUMB_LABELS = toToken(BREADCRUMB_LABELS_DEF);
+ *
+ * @example
+ * // consumer, fixed wording
+ * provideBreadcrumbLabels({ navigation: 'Brotkrumen' });
+ *
+ * // consumer, driven by the app's i18n and re-resolved on a locale change
+ * provideBreadcrumbLabels((locale) => ({ navigation: translate('breadcrumb.nav', locale) }));
+ */
+const defineLabels = (name, defaults) => {
+    const token = new InjectionToken(name, {
+        providedIn: 'root',
+        factory: () => ({}),
+    });
+    return {
+        provide: (labels) => ({ provide: token, useValue: labels }),
+        inject: () => {
+            const source = inject(token);
+            const { currentLocale } = injectLocale();
+            return computed(() => {
+                const locale = currentLocale();
+                return { ...resolveSource(defaults, locale), ...resolveSource(source, locale) };
+            });
+        },
+        token,
+    };
+};
 
-const [provideStyleManager, injectStyleManager] = createRootProvider(() => {
+const STYLE_MANAGER_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const appRef = inject(ApplicationRef);
     const destroyRef = inject(DestroyRef);
     const document = inject(DOCUMENT);
@@ -3964,6 +4220,8 @@ const [provideStyleManager, injectStyleManager] = createRootProvider(() => {
     });
     return { mount };
 }, { name: 'StyleManager' });
+const provideStyleManager = /* @__PURE__ */ toProvideFn(STYLE_MANAGER_DEF);
+const injectStyleManager = /* @__PURE__ */ toInjectFn(STYLE_MANAGER_DEF);
 
 const createUserConsentProvider = (options) => ({
     provide: options.for,
@@ -3987,8 +4245,23 @@ const fromNextFrame = () => {
         });
     });
 };
-const forceReflow = (element = document.body) => {
-    return element.offsetHeight;
+const forceReflow = (element) => {
+    // The `document.body` fallback is resolved lazily and guarded: there is nothing to reflow on the
+    // server, so this becomes a no-op instead of throwing on a missing `document`.
+    const el = element ?? (typeof document === 'undefined' ? null : document.body);
+    return el?.offsetHeight ?? 0;
+};
+/**
+ * Whether the user asked for reduced motion, read straight from `matchMedia`.
+ *
+ * Inside a component, prefer the reactive `injectPrefersReducedMotion()`. This is for the animation
+ * helpers that run from effects, event handlers and imperative APIs, where there is no injection
+ * context. Pass the element being animated so the query resolves against its own window - otherwise
+ * an animation inside an iframe would read the top-level document's preference.
+ */
+const matchesReducedMotion = (element) => {
+    const view = element?.ownerDocument.defaultView ?? (typeof window === 'undefined' ? null : window);
+    return view?.matchMedia('(prefers-reduced-motion: reduce)').matches ?? false;
 };
 
 const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken('ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN');
@@ -4214,7 +4487,7 @@ class AnimatedLifecycleDirective {
             if (!e.cancelled && e.transitionId === transitionId) {
                 return of(true);
             }
-            // The batch ended cancelled or under a different id — e.g. the browser cancelled and
+            // The batch ended cancelled or under a different id - e.g. the browser cancelled and
             // restarted a running transition mid-flight (an anchored overlay whose ancestor pane got
             // destroyed) or a foreign transition on the same element finished. If nothing is
             // animating anymore the expected end event can never arrive, so treat the transition as
@@ -4361,327 +4634,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { ifValue: [{ type: i0.Input, args: [{ isSignal: true, alias: "etAnimatedIf", required: false }] }] } });
 
-class AnimatedOverlayDirective {
-    constructor() {
-        this.overlayService = inject(Overlay);
-        this.injector = inject(Injector);
-        this.viewContainerRef = inject(ViewContainerRef);
-        this.zone = inject(NgZone);
-        this.elementRef = inject(ElementRef);
-        this.rootBoundary = injectBoundaryElement({ optional: true });
-        this.destroyRef = inject(DestroyRef);
-        this.floatingElCleanupFn = null;
-        this.unmountSubscription = null;
-        this.placement = input('bottom', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "placement" }] : /* istanbul ignore next */ []));
-        this.fallbackPlacements = input(/* @ts-ignore */
-        ...(ngDevMode ? [undefined, { debugName: "fallbackPlacements" }] : /* istanbul ignore next */ []));
-        this.offset = input(null, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "offset" }] : /* istanbul ignore next */ []));
-        this.arrowPadding = input(4, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "arrowPadding" }] : /* istanbul ignore next */ []));
-        this.viewportPadding = input(8, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "viewportPadding" }] : /* istanbul ignore next */ []));
-        this.autoResize = input(false, { ...(ngDevMode ? { debugName: "autoResize" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        this.shift = input(true, { ...(ngDevMode ? { debugName: "shift" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        this.autoHide = input(false, { ...(ngDevMode ? { debugName: "autoHide" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        this.autoCloseIfReferenceHidden = input(false, { ...(ngDevMode ? { debugName: "autoCloseIfReferenceHidden" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        this.referenceElement = input(this.elementRef.nativeElement, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "referenceElement" }] : /* istanbul ignore next */ []));
-        this.mirrorWidth = input(false, { ...(ngDevMode ? { debugName: "mirrorWidth" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        this.portal = null;
-        this.overlayRef = null;
-        this.componentRef = null;
-        this.beforeOpened$ = new Subject();
-        this.afterOpened$ = new Subject();
-        this.beforeClosed$ = new Subject();
-        this.afterClosed$ = new Subject();
-        this.state = signal('init', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
-        this.isMounted = computed(() => this.state() === 'mounted', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "isMounted" }] : /* istanbul ignore next */ []));
-        this.isMounting = computed(() => this.state() === 'mounting', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "isMounting" }] : /* istanbul ignore next */ []));
-        this.isUnmounted = computed(() => this.state() === 'unmounted', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "isUnmounted" }] : /* istanbul ignore next */ []));
-        this.isUnmounting = computed(() => this.state() === 'unmounting', /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "isUnmounting" }] : /* istanbul ignore next */ []));
-        this.canMount = computed(() => !this.isMounted() && !this.isMounting(), /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "canMount" }] : /* istanbul ignore next */ []));
-        this.canUnmount = computed(() => (this.isMounted() || this.isMounting()) && !this.isUnmounting(), /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "canUnmount" }] : /* istanbul ignore next */ []));
-        this.isHidden = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "isHidden" }] : /* istanbul ignore next */ []));
-        this.isMounted$ = toObservable(this.isMounted);
-        this.isMounting$ = toObservable(this.isMounting);
-        this.isUnmounted$ = toObservable(this.isUnmounted);
-        this.isUnmounting$ = toObservable(this.isUnmounting);
-        this.canMount$ = toObservable(this.canMount);
-        this.canUnmount$ = toObservable(this.canUnmount);
-        this.isHidden$ = toObservable(this.isHidden);
-        this.referenceElementDimensions = signalElementDimensions(computed(() => (this.mirrorWidth() ? this.referenceElement() : null)));
-        effect(() => {
-            const dimensions = this.referenceElementDimensions();
-            if (!dimensions || !this.mirrorWidth())
-                return;
-            this.overlayRef?.updateSize({
-                width: this.elementRef.nativeElement.offsetWidth,
-            });
-        });
-        this.destroyRef.onDestroy(() => this.destroy());
-    }
-    mount(config) {
-        if (this.isUnmounting()) {
-            if (!this.componentRef) {
-                if (isDevMode()) {
-                    console.warn('AnimatedOverlayDirective: Cannot remount. Component ref is not available.');
-                }
-                return;
-            }
-            this.unmountSubscription?.unsubscribe();
-            this.unmountSubscription = null;
-            this.applyComponentData(config.data);
-            this.applyColorProvider(config.colorProvider);
-            const lifecycle = this.componentRef.instance.animatedLifecycle();
-            if (lifecycle) {
-                this.state.set('mounting');
-                this.beforeOpened$.next();
-                lifecycle.enter();
-                lifecycle.state$
-                    .pipe(filter((s) => s === 'entered'), tap(() => {
-                    if (this.state() === 'mounting') {
-                        this.state.set('mounted');
-                        this.afterOpened$.next();
-                    }
-                }), take(1), takeUntilDestroyed(this.destroyRef))
-                    .subscribe();
-            }
-            return this.componentRef.instance;
-        }
-        if (!this.canMount()) {
-            if (isDevMode()) {
-                console.warn('AnimatedOverlayDirective: Cannot mount. Component is already mounted or currently mounting.');
-            }
-            return;
-        }
-        const { component, providers, data, colorProvider } = config;
-        this.state.set('mounting');
-        this.beforeOpened$.next();
-        const injector = Injector.create({
-            parent: this.injector,
-            providers: providers ?? [],
-        });
-        this.overlayRef = this.overlayService.create();
-        this.portal = new ComponentPortal(component, this.viewContainerRef, injector);
-        this.componentRef = this.overlayRef.attach(this.portal);
-        this.applyComponentData(data);
-        this.applyColorProvider(colorProvider);
-        this.updateOverlaySize();
-        this.setupFloatingUI();
-        return this.componentRef.instance;
-    }
-    unmount() {
-        if (!this.isMounted() && !this.isMounting() && !this.isUnmounting()) {
-            if (isDevMode()) {
-                console.warn(`AnimatedOverlayDirective: Cannot unmount. Component is currently ${this.state()}`);
-            }
-            return;
-        }
-        if (this.isUnmounting()) {
-            return;
-        }
-        if (!this.componentRef) {
-            if (isDevMode()) {
-                console.warn('AnimatedOverlayDirective: Cannot unmount. Component ref is not available.');
-            }
-            return;
-        }
-        this.state.set('unmounting');
-        this.beforeClosed$.next();
-        if (this.isHidden()) {
-            this.destroy();
-            return;
-        }
-        const lifecycle = this.componentRef.instance.animatedLifecycle();
-        if (!lifecycle) {
-            this.destroy();
-            return;
-        }
-        lifecycle.leave();
-        this.unmountSubscription = lifecycle.state$
-            .pipe(filter((s) => s === 'left'), take(1), takeUntilDestroyed(this.destroyRef))
-            .subscribe(() => {
-            this.unmountSubscription = null;
-            this.destroy();
-        });
-    }
-    applyComponentData(data) {
-        if (!this.componentRef || !data)
-            return;
-        Object.assign(this.componentRef.instance, data);
-        this.componentRef.changeDetectorRef.markForCheck();
-    }
-    applyColorProvider(colorProvider) {
-        if (!this.componentRef || !colorProvider)
-            return;
-        this.componentRef.instance.setColorFromProvider(colorProvider);
-    }
-    updateOverlaySize() {
-        if (!this.overlayRef || !this.mirrorWidth())
-            return;
-        this.overlayRef.updateSize({
-            width: this.elementRef.nativeElement.offsetWidth,
-        });
-    }
-    setupFloatingUI() {
-        this.zone.runOutsideAngular(() => {
-            if (!this.componentRef)
-                return;
-            const floatingEl = this.componentRef.location.nativeElement;
-            const floatingElArrow = this.getFloatingArrow();
-            floatingEl.classList.add('et-floating-element');
-            const refEl = this.referenceElement();
-            const boundary = this.rootBoundary?.value();
-            this.floatingElCleanupFn = autoUpdate(refEl, floatingEl, () => {
-                this.updateFloatingPosition(floatingEl, refEl, boundary, floatingElArrow);
-            });
-            this.waitForRenderAndAnimate();
-        });
-    }
-    getFloatingArrow() {
-        if (!this.componentRef)
-            return null;
-        return this.componentRef.location.nativeElement.querySelector('[et-floating-arrow]');
-    }
-    updateFloatingPosition(floatingEl, refEl, boundary, floatingElArrow) {
-        if (!this.componentRef)
-            return;
-        const middleware = this.buildFloatingMiddleware(floatingEl, boundary, floatingElArrow);
-        computePosition(refEl, floatingEl, {
-            placement: this.placement(),
-            middleware,
-        }).then(({ x, y, placement, middlewareData }) => {
-            this.applyFloatingStyles(floatingEl, x, y, placement);
-            this.applyArrowStyles(floatingEl, middlewareData, floatingElArrow);
-            this.handleReferenceHidden(floatingEl, middlewareData);
-        });
-    }
-    buildFloatingMiddleware(floatingEl, boundary, floatingElArrow) {
-        const middleware = [];
-        const offsetValue = this.offset();
-        if (offsetValue !== null) {
-            middleware.push(offset(offsetValue));
-        }
-        middleware.push(flip({
-            fallbackPlacements: this.fallbackPlacements() ?? undefined,
-            fallbackAxisSideDirection: 'start',
-            boundary,
-        }));
-        if (this.autoResize()) {
-            middleware.push(size({
-                padding: this.viewportPadding() ?? undefined,
-                apply({ availableHeight, availableWidth }) {
-                    floatingEl.style.setProperty('--et-floating-max-width', `${availableWidth}px`);
-                    floatingEl.style.setProperty('--et-floating-max-height', `${availableHeight}px`);
-                },
-            }));
-        }
-        if (this.shift()) {
-            middleware.push(shift({
-                limiter: limitShift(),
-                padding: this.viewportPadding() ?? undefined,
-                boundary,
-            }));
-        }
-        if (floatingElArrow) {
-            middleware.push(arrow({ element: floatingElArrow, padding: this.arrowPadding() ?? undefined }));
-        }
-        if (this.autoHide() || this.autoCloseIfReferenceHidden()) {
-            middleware.push(hide({ strategy: 'referenceHidden', boundary }));
-        }
-        return middleware;
-    }
-    applyFloatingStyles(floatingEl, x, y, placement) {
-        floatingEl.style.setProperty('--et-floating-translate', `translate3d(${x}px, ${y}px, 0)`);
-        floatingEl.setAttribute('et-floating-placement', placement);
-    }
-    applyArrowStyles(floatingEl, middlewareData, floatingElArrow) {
-        if (!middlewareData.arrow || !floatingElArrow)
-            return;
-        const { x: arrowX, y: arrowY } = middlewareData.arrow;
-        floatingEl.style.setProperty('--et-floating-arrow-translate', `translate3d(${arrowX ?? 0}px, ${arrowY ?? 0}px, 0)`);
-    }
-    handleReferenceHidden(floatingEl, middlewareData) {
-        if (middlewareData.hide?.referenceHidden) {
-            if (this.autoCloseIfReferenceHidden()) {
-                this.unmount();
-            }
-            else {
-                floatingEl.classList.add('et-floating-element--hidden');
-                this.isHidden.set(true);
-            }
-        }
-        else if (this.autoHide()) {
-            floatingEl.classList.remove('et-floating-element--hidden');
-            this.isHidden.set(false);
-        }
-    }
-    waitForRenderAndAnimate() {
-        nextFrame(() => {
-            if (!this.componentRef || this.state() !== 'mounting') {
-                return;
-            }
-            const lifecycle = this.componentRef.instance.animatedLifecycle?.();
-            if (!lifecycle) {
-                console.error('AnimatedOverlayDirective: The component does not have an AnimatedLifecycleDirective. Please add one to the component.');
-                return;
-            }
-            lifecycle.enter();
-            lifecycle.state$
-                .pipe(filter((s) => s === 'entered'), tap(() => {
-                if (this.state() === 'mounting') {
-                    this.state.set('mounted');
-                    this.afterOpened$.next();
-                }
-            }), take(1), takeUntilDestroyed(this.destroyRef))
-                .subscribe();
-        });
-    }
-    destroy() {
-        this.zone.runOutsideAngular(() => {
-            this.floatingElCleanupFn?.();
-        });
-        if (this.overlayRef) {
-            this.overlayRef.dispose();
-            this.overlayRef = null;
-        }
-        if (this.componentRef) {
-            this.componentRef.destroy();
-            this.componentRef = null;
-        }
-        this.state.set('unmounted');
-        this.afterClosed$.next();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: AnimatedOverlayDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.7", type: AnimatedOverlayDirective, isStandalone: true, selector: "[etAnimatedOverlay]", inputs: { placement: { classPropertyName: "placement", publicName: "placement", isSignal: true, isRequired: false, transformFunction: null }, fallbackPlacements: { classPropertyName: "fallbackPlacements", publicName: "fallbackPlacements", isSignal: true, isRequired: false, transformFunction: null }, offset: { classPropertyName: "offset", publicName: "offset", isSignal: true, isRequired: false, transformFunction: null }, arrowPadding: { classPropertyName: "arrowPadding", publicName: "arrowPadding", isSignal: true, isRequired: false, transformFunction: null }, viewportPadding: { classPropertyName: "viewportPadding", publicName: "viewportPadding", isSignal: true, isRequired: false, transformFunction: null }, autoResize: { classPropertyName: "autoResize", publicName: "autoResize", isSignal: true, isRequired: false, transformFunction: null }, shift: { classPropertyName: "shift", publicName: "shift", isSignal: true, isRequired: false, transformFunction: null }, autoHide: { classPropertyName: "autoHide", publicName: "autoHide", isSignal: true, isRequired: false, transformFunction: null }, autoCloseIfReferenceHidden: { classPropertyName: "autoCloseIfReferenceHidden", publicName: "autoCloseIfReferenceHidden", isSignal: true, isRequired: false, transformFunction: null }, referenceElement: { classPropertyName: "referenceElement", publicName: "referenceElement", isSignal: true, isRequired: false, transformFunction: null }, mirrorWidth: { classPropertyName: "mirrorWidth", publicName: "mirrorWidth", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "et-animated-overlay" }, exportAs: ["etAnimatedOverlay"], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: AnimatedOverlayDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[etAnimatedOverlay]',
-                    exportAs: 'etAnimatedOverlay',
-                    host: {
-                        class: 'et-animated-overlay',
-                    },
-                }]
-        }], ctorParameters: () => [], propDecorators: { placement: [{ type: i0.Input, args: [{ isSignal: true, alias: "placement", required: false }] }], fallbackPlacements: [{ type: i0.Input, args: [{ isSignal: true, alias: "fallbackPlacements", required: false }] }], offset: [{ type: i0.Input, args: [{ isSignal: true, alias: "offset", required: false }] }], arrowPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "arrowPadding", required: false }] }], viewportPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "viewportPadding", required: false }] }], autoResize: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoResize", required: false }] }], shift: [{ type: i0.Input, args: [{ isSignal: true, alias: "shift", required: false }] }], autoHide: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoHide", required: false }] }], autoCloseIfReferenceHidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoCloseIfReferenceHidden", required: false }] }], referenceElement: [{ type: i0.Input, args: [{ isSignal: true, alias: "referenceElement", required: false }] }], mirrorWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "mirrorWidth", required: false }] }] } });
-
 const createFlipAnimationGroup = (config) => {
-    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)', ignoreReducedMotion } = config;
     const flips = elements.map((el) => {
         const element = 'element' in el ? el.element : el;
         const originElement = 'originElement' in el ? el.originElement : undefined;
-        return createFlipAnimation({ element, originElement, duration, easing });
+        return createFlipAnimation({ element, originElement, duration, easing, ignoreReducedMotion });
     });
     const onStart$ = combineLatest(flips.map((animation) => animation.onStart$));
     const onFinish$ = combineLatest(flips.map((animation) => animation.onFinish$));
@@ -4705,7 +4663,7 @@ const createFlipAnimationGroup = (config) => {
     };
 };
 const createFlipAnimation = (config) => {
-    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)', ignoreReducedMotion = false, } = config;
     let initialRect = originElement.getBoundingClientRect();
     let animation = null;
     const onStart$ = new Subject();
@@ -4737,6 +4695,10 @@ const createFlipAnimation = (config) => {
             scaleX: initialRect.width / lastRect.width,
             scaleY: initialRect.height / lastRect.height,
         };
+        // Under reduced motion the element jumps straight to its final position. Collapsing the duration
+        // instead of bailing out keeps the `Animation` lifecycle intact, so callers that wait on
+        // `onFinish$` to clean up still get their event.
+        const effectiveDuration = !ignoreReducedMotion && matchesReducedMotion(el) ? 0 : duration;
         animation = el.animate([
             {
                 transformOrigin: 'top left',
@@ -4750,7 +4712,7 @@ const createFlipAnimation = (config) => {
                 transform: 'none',
             },
         ], {
-            duration,
+            duration: effectiveDuration,
             easing,
             fill: 'both',
         });
@@ -5015,7 +4977,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { commitThreshold: [{ type: i0.Input, args: [{ isSignal: true, alias: "commitThreshold", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], dragTapped: [{ type: i0.Output, args: ["dragTapped"] }], dragStarted: [{ type: i0.Output, args: ["dragStarted"] }], dragMoved: [{ type: i0.Output, args: ["dragMoved"] }], dragEnded: [{ type: i0.Output, args: ["dragEnded"] }] } });
 
-const FOCUSABLE_SELECTOR = [
+const FOCUSABLE_SELECTOR = /* @__PURE__ */ [
     'a[href]',
     'area[href]',
     'button:not([disabled])',
@@ -5176,6 +5138,56 @@ const resetPositioningStyles = (config, hostElement, paneElement, renderer) => {
     renderer.removeAttribute(paneElement, 'data-overlay-placement');
     setBaseElementStyles(config, hostElement, paneElement, renderer);
 };
+let anchoredPositionSetup = null;
+/**
+ * Installs the anchored positioning implementation. Called by `anchoredOverlayPosition()`, which is
+ * the only thing that pulls `@floating-ui/dom` into the bundle - apps that never anchor an overlay
+ * do not ship it.
+ *
+ * @internal
+ */
+const registerAnchoredPositionSetup = (setup) => {
+    anchoredPositionSetup = setup;
+};
+const setupPositioning = (config, hostElement, paneElement, overlayRef, renderer) => {
+    const strategy = config.positionStrategy ?? { kind: 'center' };
+    if (strategy.kind === 'anchored') {
+        renderer.setStyle(hostElement, {
+            pointerEvents: config.hasBackdrop === false ? 'none' : 'auto',
+        });
+        if (!anchoredPositionSetup) {
+            if (isDevMode()) {
+                console.error('An overlay was mounted with an anchored position strategy, but anchored positioning is not installed. Build the strategy with `anchoredOverlayPosition()` from @ethlete/core so the positioning code is part of the bundle.', strategy);
+            }
+            applyCenteredPosition(hostElement, paneElement, renderer, { kind: 'center' });
+            return () => undefined;
+        }
+        return anchoredPositionSetup(strategy, paneElement, overlayRef, renderer);
+    }
+    if (strategy.kind === 'global') {
+        applyGlobalPosition(hostElement, paneElement, renderer, strategy);
+        return () => undefined;
+    }
+    applyCenteredPosition(hostElement, paneElement, renderer, strategy);
+    return () => undefined;
+};
+
+let middlewareExtras = null;
+/**
+ * Installs the `size` / `arrow` / `hide` middleware. Called by
+ * `enableAnchoredOverlayPositionExtras()`.
+ *
+ * @internal
+ */
+const registerAnchoredPositionMiddlewareExtras = (extras) => {
+    middlewareExtras = extras;
+};
+const requireMiddlewareExtras = (feature) => {
+    if (!middlewareExtras && isDevMode()) {
+        console.error(`An anchored overlay uses "${feature}", but the matching floating-ui middleware is not installed. Call \`enableAnchoredOverlayPositionExtras()\` from @ethlete/core once during app setup.`);
+    }
+    return middlewareExtras;
+};
 const createAnchoredPositionCleanup = (strategy, paneElement, overlayRef, renderer) => {
     // mirrorWidth needs a real element to measure; virtual references fall back to max-content
     const mirrorWidthElement = strategy.mirrorWidth && isHTMLElement(strategy.referenceElement) ? strategy.referenceElement : null;
@@ -5202,29 +5214,41 @@ const createAnchoredPositionCleanup = (strategy, paneElement, overlayRef, render
                 boundary: strategy.boundary,
             }));
         }
-        // size must run AFTER shift so the available space is measured from the shifted position —
+        // size must run AFTER shift so the available space is measured from the shifted position -
         // otherwise a cross-axis-shifted pane gets its max size capped to the unshifted leftover space
         if (strategy.autoResize) {
-            middleware.push(size({
-                padding: strategy.viewportPadding ?? 8,
-                apply({ availableHeight, availableWidth }) {
-                    renderer.setCssProperties(paneElement, {
-                        '--et-overlay-max-width': `${availableWidth}px`,
-                        '--et-overlay-max-height': `${availableHeight}px`,
-                    });
-                },
-            }));
+            const extras = requireMiddlewareExtras('autoResize');
+            if (extras) {
+                middleware.push(extras.size({
+                    padding: strategy.viewportPadding ?? 8,
+                    apply({ availableHeight, availableWidth }) {
+                        renderer.setCssProperties(paneElement, {
+                            '--et-overlay-max-width': `${availableWidth}px`,
+                            '--et-overlay-max-height': `${availableHeight}px`,
+                        });
+                    },
+                }));
+            }
         }
         if (arrowElement) {
-            middleware.push(arrow({
-                element: arrowElement,
-                padding: strategy.arrowPadding ?? 4,
-            }));
+            const extras = requireMiddlewareExtras('arrow');
+            if (extras) {
+                middleware.push(extras.arrow({
+                    element: arrowElement,
+                    // keeps the arrow off a rounded pane corner by default: 12px covers the radius of the
+                    // built-in boxed panes (--et-overlay-radius). Panes with a larger radius have to pass their
+                    // own - an arrow whose base sits on the corner arc looks detached from the pane.
+                    padding: strategy.arrowPadding ?? 12,
+                }));
+            }
         }
         if (strategy.autoHide || strategy.autoCloseIfReferenceHidden) {
-            middleware.push(hide({
-                strategy: 'referenceHidden',
-            }));
+            const extras = requireMiddlewareExtras('autoHide');
+            if (extras) {
+                middleware.push(extras.hide({
+                    strategy: 'referenceHidden',
+                }));
+            }
         }
         computePosition(strategy.referenceElement, paneElement, {
             placement: strategy.placement ?? 'bottom',
@@ -5265,20 +5289,29 @@ const createAnchoredPositionCleanup = (strategy, paneElement, overlayRef, render
         cleanup();
     };
 };
-const setupPositioning = (config, hostElement, paneElement, overlayRef, renderer) => {
-    const strategy = config.positionStrategy ?? { kind: 'center' };
-    if (strategy.kind === 'anchored') {
-        renderer.setStyle(hostElement, {
-            pointerEvents: config.hasBackdrop === false ? 'none' : 'auto',
-        });
-        return createAnchoredPositionCleanup(strategy, paneElement, overlayRef, renderer);
-    }
-    if (strategy.kind === 'global') {
-        applyGlobalPosition(hostElement, paneElement, renderer, strategy);
-        return () => undefined;
-    }
-    applyCenteredPosition(hostElement, paneElement, renderer, strategy);
-    return () => undefined;
+/**
+ * Builds an anchored position strategy and installs the anchored positioning implementation.
+ *
+ * Anchored positioning is the only part of the overlay runtime that needs `@floating-ui/dom`, and it
+ * is reachable only through this function - an app that positions its overlays centered or globally
+ * never bundles it. Always build anchored strategies with this helper instead of a plain
+ * `{ kind: 'anchored', ... }` literal.
+ *
+ * Overlays that set `autoResize`, `autoHide`, `autoCloseIfReferenceHidden` or render an arrow
+ * additionally need `enableAnchoredOverlayPositionExtras()`.
+ */
+const anchoredOverlayPosition = (config) => {
+    registerAnchoredPositionSetup(createAnchoredPositionCleanup);
+    return { kind: 'anchored', ...config };
+};
+
+/**
+ * Installs the floating-ui middleware anchored overlays need for `autoResize`, `autoHide`,
+ * `autoCloseIfReferenceHidden` and arrows. Call it once wherever such an overlay is built - an
+ * anchored overlay that uses none of those features does not bundle this middleware.
+ */
+const enableAnchoredOverlayPositionExtras = () => {
+    registerAnchoredPositionMiddlewareExtras({ size, arrow, hide });
 };
 
 const createOverlayRuntimeRef = (id, config, elements, requestClose) => {
@@ -5298,13 +5331,13 @@ const createOverlayRuntimeRef = (id, config, elements, requestClose) => {
         elements,
         state: _state.asReadonly(),
         componentInstance: _componentInstance.asReadonly(),
-        // Internal — driven by overlay-runtime.ts
+        // Internal - driven by overlay-runtime.ts
         beforeOpenedSubject,
         close(result, source = 'api') {
             if (_state() === 'closing' || _state() === 'closed') {
                 return;
             }
-            // `reference-detached` is a forced teardown (the anchor is gone) — never vetoable.
+            // `reference-detached` is a forced teardown (the anchor is gone) - never vetoable.
             if (source !== 'reference-detached') {
                 for (const guard of closeGuards) {
                     if (!guard({ result, source })) {
@@ -5314,7 +5347,7 @@ const createOverlayRuntimeRef = (id, config, elements, requestClose) => {
             }
             requestClose(result, source);
         },
-        /** Close bypassing every registered close guard — used by a guard's owner to commit a
+        /** Close bypassing every registered close guard - used by a guard's owner to commit a
          *  close it previously vetoed (e.g. after an async confirm resolved). */
         forceClose(result, source = 'api') {
             if (_state() === 'closing' || _state() === 'closed') {
@@ -5381,7 +5414,7 @@ const createOverlayRuntimeRef = (id, config, elements, requestClose) => {
     };
 };
 
-const [provideOverlayRuntime, injectOverlayRuntime] = createRootProvider(() => {
+const OVERLAY_RUNTIME_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const appRef = inject(ApplicationRef);
     const destroyRef = inject(DestroyRef);
     const document = inject(DOCUMENT);
@@ -5488,7 +5521,7 @@ const [provideOverlayRuntime, injectOverlayRuntime] = createRootProvider(() => {
             hostElement: paneElement,
             bindings: config.bindings ?? [],
         });
-        // pane classes are applied after component creation — Angular replaces the host
+        // pane classes are applied after component creation - Angular replaces the host
         // element's class attribute with the component's static host class on creation
         renderer.addClass(paneElement, 'et-overlay-runtime-pane', ...(config.paneClass ?? []));
         appRef.attachView(componentRef.hostView);
@@ -5535,7 +5568,7 @@ const [provideOverlayRuntime, injectOverlayRuntime] = createRootProvider(() => {
             }
             const lifecycle = getAnimatedLifecycle(componentRef);
             animationDebugLog(`runtime ${config.id}`, `close requested (source "${closeEvent.source}", lifecycle state "${lifecycle?.state$.value ?? 'none'}", delegate ${config.animationDelegate?.leave ? 'yes' : 'no'})`);
-            // The reference element is gone — there is nothing left to animate away from, so tear the
+            // The reference element is gone - there is nothing left to animate away from, so tear the
             // overlay down synchronously instead of playing a leave transition from a stale position.
             if (!lifecycle || closeEvent.source === 'reference-detached') {
                 destroyMountedOverlay(closeEvent);
@@ -5644,6 +5677,8 @@ const [provideOverlayRuntime, injectOverlayRuntime] = createRootProvider(() => {
         openEntries,
     };
 }, { name: 'OverlayRuntime' });
+const provideOverlayRuntime = /* @__PURE__ */ toProvideFn(OVERLAY_RUNTIME_DEF);
+const injectOverlayRuntime = /* @__PURE__ */ toInjectFn(OVERLAY_RUNTIME_DEF);
 
 class NormalizeGameResultTypePipe {
     constructor() {
@@ -6684,7 +6719,7 @@ const toStringBinding = (binding) => {
         return value !== null && value !== undefined ? String(value) : null;
     });
 };
-const createBulkPropertyBinding = (propertyPrefix, applyConfigFn) => {
+const createBulkPropertyBinding = (_propertyPrefix, applyConfigFn) => {
     return (config) => {
         Object.entries(config).forEach(([key, value]) => {
             if (value !== undefined) {
@@ -6694,11 +6729,202 @@ const createBulkPropertyBinding = (propertyPrefix, applyConfigFn) => {
     };
 };
 
+/** The rendered favicon is this many device-independent pixels square. */
+const FAVICON_SIZE = 64;
+/** Fallback when the color theming tokens aren't resolvable (no theme applied to the root element). */
+const FALLBACK_OVERLAY_COLOR = '#e11d48';
+const readThemeColor = (document) => {
+    const value = getComputedStyle(document.documentElement).getPropertyValue('--et-theme-color-primary-solid').trim();
+    return value || FALLBACK_OVERLAY_COLOR;
+};
+const drawDot = (ctx, color) => {
+    const radius = FAVICON_SIZE * 0.19;
+    const center = FAVICON_SIZE - radius - 3;
+    // Punch a hole first so the badge reads on top of a busy icon, then fill it.
+    ctx.save();
+    ctx.globalCompositeOperation = 'destination-out';
+    ctx.beginPath();
+    ctx.arc(center, center, radius * 1.35, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+    ctx.beginPath();
+    ctx.arc(center, center, radius, 0, Math.PI * 2);
+    ctx.fillStyle = color;
+    ctx.fill();
+};
+const drawProgress = (ctx, value, color, trackColor) => {
+    const lineWidth = FAVICON_SIZE * 0.14;
+    const radius = (FAVICON_SIZE - lineWidth) / 2;
+    const center = FAVICON_SIZE / 2;
+    const clamped = Math.min(100, Math.max(0, value));
+    const start = -Math.PI / 2;
+    ctx.lineWidth = lineWidth;
+    ctx.lineCap = 'butt';
+    // Clear the ring's lane so the base icon doesn't show through a semi-transparent track.
+    ctx.save();
+    ctx.globalCompositeOperation = 'destination-out';
+    ctx.strokeStyle = '#000';
+    ctx.beginPath();
+    ctx.arc(center, center, radius, 0, Math.PI * 2);
+    ctx.stroke();
+    ctx.restore();
+    ctx.strokeStyle = trackColor;
+    ctx.beginPath();
+    ctx.arc(center, center, radius, 0, Math.PI * 2);
+    ctx.stroke();
+    if (clamped > 0) {
+        ctx.strokeStyle = color;
+        ctx.beginPath();
+        ctx.arc(center, center, radius, start, start + (Math.PI * 2 * clamped) / 100);
+        ctx.stroke();
+    }
+};
+const FAVICON_STORE_DEF = /* @__PURE__ */ defineRootProvider(() => {
+    const document = inject(DOCUMENT);
+    const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    const overlays = signal(new Map(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "overlays" }] : /* istanbul ignore next */ []));
+    const activeOverlay = computed(() => {
+        const all = Array.from(overlays().values());
+        return all.find((overlay) => overlay.kind === 'progress') ?? all[all.length - 1] ?? null;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "activeOverlay" }] : /* istanbul ignore next */ []));
+    let iconLink = null;
+    let createdIconLink = false;
+    let originalHref = null;
+    let baseImage = null;
+    let baseImageFailed = false;
+    const resolveIconLink = () => {
+        if (iconLink) {
+            return iconLink;
+        }
+        iconLink = document.querySelector('link[rel~="icon"]');
+        if (!iconLink) {
+            iconLink = document.createElement('link');
+            iconLink.rel = 'icon';
+            document.head.appendChild(iconLink);
+            createdIconLink = true;
+        }
+        originalHref = createdIconLink ? null : iconLink.getAttribute('href');
+        return iconLink;
+    };
+    const restore = () => {
+        if (!iconLink)
+            return;
+        if (createdIconLink) {
+            iconLink.remove();
+            iconLink = null;
+            createdIconLink = false;
+            return;
+        }
+        if (originalHref === null) {
+            iconLink.removeAttribute('href');
+        }
+        else {
+            iconLink.setAttribute('href', originalHref);
+        }
+    };
+    // The base icon is loaded once and reused; a favicon that can't be read (cross-origin without
+    // CORS headers, an SVG without intrinsic size) draws on an empty canvas instead of failing.
+    const loadBaseImage = () => {
+        if (baseImage || baseImageFailed || !originalHref) {
+            return Promise.resolve(baseImage);
+        }
+        return new Promise((resolve) => {
+            const image = new Image();
+            image.onload = () => {
+                baseImage = image;
+                resolve(image);
+            };
+            image.onerror = () => {
+                baseImageFailed = true;
+                resolve(null);
+            };
+            image.src = originalHref;
+        });
+    };
+    const render = async (overlay) => {
+        const canvas = document.createElement('canvas');
+        canvas.width = FAVICON_SIZE;
+        canvas.height = FAVICON_SIZE;
+        // No 2d context (a non-browser DOM implementation) - leave the favicon untouched entirely.
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return;
+        const link = resolveIconLink();
+        const image = await loadBaseImage();
+        // A later state may have won the race while the base image loaded.
+        if (activeOverlay() !== overlay)
+            return;
+        if (image) {
+            ctx.drawImage(image, 0, 0, FAVICON_SIZE, FAVICON_SIZE);
+        }
+        const color = overlay.color ?? readThemeColor(document);
+        if (overlay.kind === 'dot') {
+            drawDot(ctx, color);
+        }
+        else {
+            drawProgress(ctx, overlay.value, color, overlay.trackColor ?? 'rgba(127, 127, 127, 0.35)');
+        }
+        try {
+            link.setAttribute('href', canvas.toDataURL('image/png'));
+        }
+        catch {
+            // A tainted canvas (cross-origin base icon) can't be exported - leave the favicon as it was.
+            restore();
+        }
+    };
+    if (isBrowser) {
+        effect(() => {
+            const overlay = activeOverlay();
+            if (!overlay) {
+                restore();
+                return;
+            }
+            void render(overlay);
+        });
+    }
+    const addOverlay = (id, overlay) => {
+        overlays.update((current) => new Map(current).set(id, overlay));
+    };
+    const removeOverlay = (id) => {
+        overlays.update((current) => {
+            const next = new Map(current);
+            next.delete(id);
+            return next;
+        });
+    };
+    return { activeOverlay, addOverlay, removeOverlay };
+}, { name: 'Favicon Store' });
+/**
+ * Owns the `<link rel="icon">` href so overlays can be drawn onto the site's favicon and taken back
+ * off again. The original href is captured on first use and restored once the last overlay is gone.
+ *
+ * Registrations are keyed, and a `progress` overlay wins over a `dot` - a ring that also carries a
+ * badge reads as neither.
+ */
+const provideFaviconStore = /* @__PURE__ */ toProvideFn(FAVICON_STORE_DEF);
+const injectFaviconStore = /* @__PURE__ */ toInjectFn(FAVICON_STORE_DEF);
+/**
+ * Draw an overlay on the site's favicon while the binding has a value - an unsaved-changes dot, an
+ * upload's progress ring. The favicon is restored when the binding goes empty or the injector is
+ * destroyed. No-op during SSR.
+ *
+ * ```ts
+ * applyFaviconOverlay(computed(() => (this.saving() ? { kind: 'progress', value: this.percent() } : null)));
+ * ```
+ */
+const applyFaviconOverlay = (binding) => {
+    const faviconStore = injectFaviconStore();
+    const overlayId = Symbol('favicon-overlay');
+    applyHeadBinding(binding, (value) => faviconStore.addOverlay(overlayId, value), () => faviconStore.removeOverlay(overlayId));
+};
+
 var jsonLd = /*#__PURE__*/Object.freeze({
     __proto__: null
 });
 
-const DEFAULT_MULTI_INSTANCE_RELS = new Set([
+const DEFAULT_MULTI_INSTANCE_RELS = /* @__PURE__ */ new Set([
     'alternate',
     'icon',
     'apple-touch-icon',
@@ -6711,10 +6937,12 @@ const DEFAULT_MULTI_INSTANCE_RELS = new Set([
     'stylesheet',
     'modulepreload',
 ]);
-const [provideLinkStoreConfig, injectLinkStoreConfig] = createStaticRootProvider({
+const LINK_STORE_CONFIG_DEF = /* @__PURE__ */ defineStaticRootProvider({
     multiInstanceRels: DEFAULT_MULTI_INSTANCE_RELS,
 }, { name: 'Link Store Config' });
-const [provideLinkStore, injectLinkStore] = createRootProvider(() => {
+const provideLinkStoreConfig = /* @__PURE__ */ toProvideFn(LINK_STORE_CONFIG_DEF);
+const injectLinkStoreConfig = /* @__PURE__ */ toInjectFn(LINK_STORE_CONFIG_DEF);
+const LINK_STORE_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const document = inject(DOCUMENT$1);
     const config = injectLinkStoreConfig();
     const linksByKey = signal(new Map(), /* @ts-ignore */
@@ -6750,7 +6978,6 @@ const [provideLinkStore, injectLinkStore] = createRootProvider(() => {
     };
     const createLinkElement = (linkConfig) => {
         const link = document.createElement('link');
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { key, allowMultiple, ...attributes } = linkConfig;
         Object.entries(attributes).forEach(([attrKey, value]) => {
             if (value !== undefined && value !== null) {
@@ -6835,6 +7062,8 @@ const [provideLinkStore, injectLinkStore] = createRootProvider(() => {
     };
     return { addLink, removeLink, getLinkKey };
 }, { name: 'Link Store' });
+const provideLinkStore = /* @__PURE__ */ toProvideFn(LINK_STORE_DEF);
+const injectLinkStore = /* @__PURE__ */ toInjectFn(LINK_STORE_DEF);
 const applyLinkBinding = (binding) => {
     const linkStore = injectLinkStore();
     const linkId = Symbol('link-tag');
@@ -6844,7 +7073,7 @@ const applyLinkBinding = (binding) => {
         linkStore.addLink(linkId, config);
     }, () => linkStore.removeLink(linkId, currentKey));
 };
-const applyCanonicalBinding = createPropertyBinding((href) => ({ rel: 'canonical', href }), applyLinkBinding);
+const applyCanonicalBinding = /* @__PURE__ */ createPropertyBinding((href) => ({ rel: 'canonical', href }), applyLinkBinding);
 const applyAlternateBinding = (hreflang, binding) => {
     applyLinkBinding(computed(() => {
         const url = untracked(() => (isSignal(binding) ? binding() : binding));
@@ -6856,8 +7085,8 @@ const applyAlternateLanguagesBindings = (config) => {
         applyAlternateBinding(hreflang, binding);
     });
 };
-const applyPrevBinding = createPropertyBinding((href) => ({ rel: 'prev', href }), applyLinkBinding);
-const applyNextBinding = createPropertyBinding((href) => ({ rel: 'next', href }), applyLinkBinding);
+const applyPrevBinding = /* @__PURE__ */ createPropertyBinding((href) => ({ rel: 'prev', href }), applyLinkBinding);
+const applyNextBinding = /* @__PURE__ */ createPropertyBinding((href) => ({ rel: 'next', href }), applyLinkBinding);
 const applyResourceHintsBindings = (config) => {
     if (config.preconnect) {
         createArrayPropertyBinding((href, index) => ({ rel: 'preconnect', href, key: `preconnect:${index}` }), applyLinkBinding)(config.preconnect);
@@ -6873,20 +7102,26 @@ const applyResourceHintsBindings = (config) => {
     }
 };
 
-const [provideTitleConfig, injectTitleConfig] = createStaticRootProvider({
+const TITLE_CONFIG_DEF = /* @__PURE__ */ defineStaticRootProvider({
     divider: '|',
     defaultTitle: '',
     transformer: (title) => title,
 }, { name: 'Title Config' });
-const [provideTitleStore, injectTitleStore] = createRootProvider(() => {
+const provideTitleConfig = /* @__PURE__ */ toProvideFn(TITLE_CONFIG_DEF);
+const injectTitleConfig = /* @__PURE__ */ toInjectFn(TITLE_CONFIG_DEF);
+const TITLE_STORE_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const config = injectTitleConfig();
     const titleParts = signal(new Map(), /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "titleParts" }] : /* istanbul ignore next */ []));
+    const titleMarkers = signal(new Map(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "titleMarkers" }] : /* istanbul ignore next */ []));
     const { currentLocale } = injectLocale();
     const titleService = inject(Title);
     const isRouterInitialized = injectIsRouterInitialized();
-    const defaultTitle = config.defaultTitle ?? titleService.getTitle();
-    const title = computed(() => {
+    // Falls back on an empty configured default too, so a store created lazily (e.g. by a title
+    // marker) doesn't wipe a title that came from `index.html`.
+    const defaultTitle = config.defaultTitle || titleService.getTitle();
+    const composedTitle = computed(() => {
         const partsMap = titleParts();
         if (!partsMap.size || !isRouterInitialized()) {
             return config.transformer(defaultTitle, currentLocale());
@@ -6910,6 +7145,20 @@ const [provideTitleStore, injectTitleStore] = createRootProvider(() => {
         }
         return finalTextParts.join(` ${config.divider} `);
     }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "composedTitle" }] : /* istanbul ignore next */ []));
+    /**
+     * The composed title with any markers prefixed - what actually lands in `document.title`.
+     * Markers sit outside the divider logic, so `● Page | App` rather than `● | Page | App`.
+     */
+    const title = computed(() => {
+        // Deduplicated: two forms with unsaved changes should read as one marker, not two.
+        const markers = Array.from(new Set(titleMarkers().values()));
+        const composed = composedTitle();
+        if (!markers.length) {
+            return composed;
+        }
+        return `${markers.join(' ')} ${composed}`.trim();
+    }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "title" }] : /* istanbul ignore next */ []));
     const addPart = (id, part) => {
         titleParts.update((parts) => new Map(parts).set(id, part));
@@ -6921,19 +7170,41 @@ const [provideTitleStore, injectTitleStore] = createRootProvider(() => {
             return newParts;
         });
     };
+    const addMarker = (id, marker) => {
+        titleMarkers.update((markers) => new Map(markers).set(id, marker));
+    };
+    const removeMarker = (id) => {
+        titleMarkers.update((markers) => {
+            const newMarkers = new Map(markers);
+            newMarkers.delete(id);
+            return newMarkers;
+        });
+    };
     effect(() => {
         const titleText = title();
         titleService.setTitle(titleText);
     });
-    return { title, addPart, removePart };
+    return { title, addPart, removePart, addMarker, removeMarker };
 }, { name: 'Title Store' });
+const provideTitleStore = /* @__PURE__ */ toProvideFn(TITLE_STORE_DEF);
+const injectTitleStore = /* @__PURE__ */ toInjectFn(TITLE_STORE_DEF);
 const applyHeadTitleBinding = (binding, options) => {
     const titleStore = injectTitleStore();
     const partId = Symbol('title-part');
     applyHeadBinding(binding, (value) => titleStore.addPart(partId, { text: `${value}`, ...options }), () => titleStore.removePart(partId), (value) => value !== null && value !== undefined && value !== '');
 };
+/**
+ * Prefix the tab title with a short marker (`● Page | App`) while the binding has a value - the
+ * unsaved-changes dot, a pending-count badge, and the like. The marker is removed when the binding
+ * goes empty and on destroy. Unlike a title part, it is not joined by the divider.
+ */
+const applyHeadTitleMarker = (binding) => {
+    const titleStore = injectTitleStore();
+    const markerId = Symbol('title-marker');
+    applyHeadBinding(binding, (value) => titleStore.addMarker(markerId, value), () => titleStore.removeMarker(markerId), (value) => value !== null && value !== undefined && value !== '');
+};
 
-const DEFAULT_MULTI_INSTANCE_TAGS = new Set([
+const DEFAULT_MULTI_INSTANCE_TAGS = /* @__PURE__ */ new Set([
     // Open Graph - Media
     'property="og:image"',
     'property="og:image:url"',
@@ -7002,11 +7273,13 @@ const DEFAULT_MULTI_INSTANCE_TAGS = new Set([
     'name="p:domain_verify"', // Pinterest
     'name="facebook-domain-verification"',
 ]);
-const [provideMetaConfig, injectMetaConfig] = createStaticRootProvider({
+const META_CONFIG_DEF = /* @__PURE__ */ defineStaticRootProvider({
     transformer: (content) => content,
     multiInstanceTags: DEFAULT_MULTI_INSTANCE_TAGS,
 }, { name: 'Meta Config' });
-const [provideMetaStore, injectMetaStore] = createRootProvider(() => {
+const provideMetaConfig = /* @__PURE__ */ toProvideFn(META_CONFIG_DEF);
+const injectMetaConfig = /* @__PURE__ */ toInjectFn(META_CONFIG_DEF);
+const META_STORE_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const metaService = inject(Meta);
     const config = injectMetaConfig();
     const { currentLocale } = injectLocale();
@@ -7032,7 +7305,6 @@ const [provideMetaStore, injectMetaStore] = createRootProvider(() => {
         if (transformedConfig.content) {
             transformedConfig.content = config.transformer(transformedConfig.content, locale);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { key, allowMultiple, ...metaConfig } = transformedConfig;
         return metaService.addTag(metaConfig);
     };
@@ -7119,6 +7391,8 @@ const [provideMetaStore, injectMetaStore] = createRootProvider(() => {
     });
     return { addTag, removeTag, getSelector };
 }, { name: 'Meta Store' });
+const provideMetaStore = /* @__PURE__ */ toProvideFn(META_STORE_DEF);
+const injectMetaStore = /* @__PURE__ */ toInjectFn(META_STORE_DEF);
 const applyMetaBinding = (binding) => {
     const metaStore = injectMetaStore();
     const tagId = Symbol('meta-tag');
@@ -7128,14 +7402,14 @@ const applyMetaBinding = (binding) => {
         metaStore.addTag(tagId, config);
     }, () => metaStore.removeTag(tagId, currentSelector));
 };
-const applyDescriptionBinding = createPropertyBinding((content) => ({ name: 'description', content }), applyMetaBinding);
+const applyDescriptionBinding = /* @__PURE__ */ createPropertyBinding((content) => ({ name: 'description', content }), applyMetaBinding);
 const applyKeywordsBinding = (binding) => {
     applyMetaBinding(computed(() => {
         const keywords = untracked(() => (isSignal(binding) ? binding() : binding));
         return keywords && keywords.length > 0 ? { name: 'keywords', content: keywords.join(', ') } : null;
     }));
 };
-const applyAuthorBinding = createPropertyBinding((content) => ({ name: 'author', content }), applyMetaBinding);
+const applyAuthorBinding = /* @__PURE__ */ createPropertyBinding((content) => ({ name: 'author', content }), applyMetaBinding);
 const applyRobotsBinding = (binding) => {
     applyMetaBinding(computed(() => {
         const config = untracked(() => (isSignal(binding) ? binding() : binding));
@@ -7448,10 +7722,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }] });
 
-const [provideStructuredDataConfig, injectStructuredDataConfig] = createStaticRootProvider({
+const STRUCTURED_DATA_CONFIG_DEF = /* @__PURE__ */ defineStaticRootProvider({
     placement: 'body',
 }, { name: 'Structured Data Config' });
-const [provideStructuredDataStore, injectStructuredDataStore] = createRootProvider(() => {
+const provideStructuredDataConfig = /* @__PURE__ */ toProvideFn(STRUCTURED_DATA_CONFIG_DEF);
+const injectStructuredDataConfig = /* @__PURE__ */ toInjectFn(STRUCTURED_DATA_CONFIG_DEF);
+const STRUCTURED_DATA_STORE_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const document = inject(DOCUMENT$1);
     const renderer = injectRenderer();
     const config = injectStructuredDataConfig();
@@ -7468,7 +7744,11 @@ const [provideStructuredDataStore, injectStructuredDataStore] = createRootProvid
                 renderer.removeChild(oldScript.parentNode, oldScript);
             }
             const script = renderer.createElement('script');
-            renderer.setAttributes(script, { type: 'application/ld+json', text: JSON.stringify(data) });
+            renderer.setAttributes(script, { type: 'application/ld+json' });
+            // The JSON is the script's *content*, not an attribute. Written as text rather than markup so a
+            // `</script>` inside a string can't close the tag early - the escaping problem
+            // `StructuredDataComponent` has to solve by hand because it goes through `innerHTML`.
+            renderer.setTextContent(script, JSON.stringify(data));
             const target = getTargetElement();
             renderer.appendChild(target, script);
             newScripts.set(id, script);
@@ -7488,6 +7768,8 @@ const [provideStructuredDataStore, injectStructuredDataStore] = createRootProvid
     };
     return { addStructuredData, removeStructuredData };
 }, { name: 'Structured Data Store' });
+const provideStructuredDataStore = /* @__PURE__ */ toProvideFn(STRUCTURED_DATA_STORE_DEF);
+const injectStructuredDataStore = /* @__PURE__ */ toInjectFn(STRUCTURED_DATA_STORE_DEF);
 const applyStructuredDataBinding = (binding) => {
     const store = injectStructuredDataStore();
     const scriptId = Symbol('structured-data');
@@ -7537,12 +7819,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
 
 /**
  * Cascades hover/active-driven color DOWN to descendants explicitly marked with
- * `ColorInteractiveDirective` — this element does not color itself. Use it when a wrapper should
+ * `ColorInteractiveDirective` - this element does not color itself. Use it when a wrapper should
  * expand a nested control's hit/visual area (e.g. clicking a checkbox's label should light up the
- * checkbox itself), never to give a wrapper its own interactive coloring — that's
+ * checkbox itself), never to give a wrapper its own interactive coloring - that's
  * `ColorInteractiveDirective`.
  *
- * Does nothing unless at least one descendant carries `ColorInteractiveDirective` — check for
+ * Does nothing unless at least one descendant carries `ColorInteractiveDirective` - check for
  * that before adding this. It was mistakenly added to a component with no such descendant once
  * already, where it did nothing but was confusing to read.
  */
@@ -7568,9 +7850,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
  * Marks a descendant as NOT counting toward an ancestor's `ColorInteractiveDirective`
  * `:hover`/`:active` reaction (via the `:has()` guard in color-interactive-styles.component.css).
  * Use it for content that's incidentally inside an interactive ancestor but isn't part of what
- * makes that ancestor interactive — e.g. a hint/error block sitting inside a form field's frame.
+ * makes that ancestor interactive - e.g. a hint/error block sitting inside a form field's frame.
  *
- * This only suppresses the ancestor's OWN reaction to hovering/pressing the excluded element — it
+ * This only suppresses the ancestor's OWN reaction to hovering/pressing the excluded element - it
  * has no effect on custom-property inheritance into descendants past the excluded element. If
  * what you actually need is "stop my own cosmetic styling from reacting to a parent's unrelated
  * interaction," this is the wrong tool; that's the class of bug `ColorInteractiveHasFocusDirective`
@@ -7592,7 +7874,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
 
 /**
  * Tints `--et-theme-color-primary-*` etc. only when a descendant genuinely has `:focus-visible`
- * (`:has(:focus-visible)`) — never on mouse `:hover`/`:active`. Use this for a wrapper (like a
+ * (`:has(:focus-visible)`) - never on mouse `:hover`/`:active`. Use this for a wrapper (like a
  * form field's frame) that should show the theme color while its control is focused, but must
  * NOT react to incidental mouse interaction with unrelated nested widgets (a toolbar button, a
  * rendered link) that happen to live inside the same wrapper.
@@ -7604,7 +7886,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
  * Deliberately does NOT also carry `ColorInteractiveDirective`'s `et-color-interactive` class:
  * that class's plain `:hover`/`:active` rules locally override the same (inheriting)
  * `--et-theme-color-primary-rgb`, so anything bubbling up from ANYWHERE in the subtree would
- * leak the transient hover/press color into every descendant reading it for unrelated cosmetics —
+ * leak the transient hover/press color into every descendant reading it for unrelated cosmetics -
  * exactly the bug this directive's only consumer (form-field) shipped once, before the two
  * behaviors were split apart. If you need the plain hover/active reaction too, add
  * `ColorInteractiveDirective` explicitly and make sure you actually want both.
@@ -7630,13 +7912,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
 /**
  * Makes an element react to ITS OWN `:hover`/`:active`/`:focus-visible`/`[disabled]` by tinting
  * `--et-theme-color-primary-*`/`-on-primary-*`/`-ink-*` with the current color theme. Use this on
- * a single, self-contained interactive element — a button, a checkbox, a segmented button.
+ * a single, self-contained interactive element - a button, a checkbox, a segmented button.
  *
  * Do NOT apply this to a wrapper that also contains OTHER, independently-interactive elements
  * (e.g. a toolbar with its own buttons, or a form-field's control slot). These are ordinary
  * inheriting CSS custom properties, so a descendant reading them for its own cosmetics (a caret
  * color, a link color) gets swept along whenever ANYTHING inside the wrapper is hovered or
- * clicked — not just when the wrapper itself is the thing being interacted with. That exact bug
+ * clicked - not just when the wrapper itself is the thing being interacted with. That exact bug
  * shipped once already; see ColorInteractiveContainerDirective/ColorInteractiveHasFocusDirective
  * for the shapes that avoid it.
  */
@@ -7664,19 +7946,23 @@ const SURFACE_TYPE = {
 };
 const createCssSurfaceName = (name) => name.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
 const resolveSurfaceByElevation = (themes, type, elevation) => themes.find((t) => t.type === type && t.elevation === elevation) ?? null;
-const [ɵProvideSurfaceThemes, injectSurfaceThemes] = createStaticProvider(undefined, {
+const SURFACE_THEMES_DEF = /* @__PURE__ */ defineStaticProvider(undefined, {
     name: 'Surface Themes',
 });
-const [ɵProvideSurfaceThemesPrefix, injectSurfaceThemesPrefix] = createStaticProvider('et', {
+const ɵProvideSurfaceThemes = /* @__PURE__ */ toProvideFn(SURFACE_THEMES_DEF);
+const injectSurfaceThemes = /* @__PURE__ */ toInjectFn(SURFACE_THEMES_DEF);
+const SURFACE_THEMES_PREFIX_DEF = /* @__PURE__ */ defineStaticProvider('et', {
     name: 'Surface Themes Prefix',
 });
+const ɵProvideSurfaceThemesPrefix = /* @__PURE__ */ toProvideFn(SURFACE_THEMES_PREFIX_DEF);
+const injectSurfaceThemesPrefix = /* @__PURE__ */ toInjectFn(SURFACE_THEMES_PREFIX_DEF);
 const provideSurfaceThemesWithTailwind4 = (themes, prefix = 'et') => [
     ɵProvideSurfaceThemes(themes),
     ɵProvideSurfaceThemesPrefix(prefix),
 ];
 
 const SURFACE_PROVIDER = new InjectionToken('SurfaceProvider');
-const FORCED_SURFACE_UNSET = Symbol('FORCED_SURFACE_UNSET');
+const FORCED_SURFACE_UNSET = /* @__PURE__ */ Symbol('FORCED_SURFACE_UNSET');
 class ProvideSurfaceDirective {
     constructor() {
         this.themes = injectSurfaceThemes({ optional: true });
@@ -7775,7 +8061,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
         }], propDecorators: { surface: [{ type: i0.Input, args: [{ isSignal: true, alias: "etProvideSurface", required: false }] }] } });
 
 let uniqueId = 0;
-const [provideSurfaceContextTracker, injectSurfaceContextTracker] = createRootProvider(() => {
+const SURFACE_CONTEXT_TRACKER_DEF = /* @__PURE__ */ defineRootProvider(() => {
     const entries = signal([], /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
     const topEntry = computed(() => {
@@ -7808,12 +8094,14 @@ const [provideSurfaceContextTracker, injectSurfaceContextTracker] = createRootPr
     };
     return { topType, topElevation, register, surfaceForElement };
 }, { name: 'SurfaceContextTracker' });
+const provideSurfaceContextTracker = /* @__PURE__ */ toProvideFn(SURFACE_CONTEXT_TRACKER_DEF);
+const injectSurfaceContextTracker = /* @__PURE__ */ toInjectFn(SURFACE_CONTEXT_TRACKER_DEF);
 
 class AutoSurfaceDirective {
     /**
      * Mark this auto-surface as its overlay's *own painted surface*. An overlay *panel*
      * (menu, select/date/cascader panel, tooltip, toggletip, rich-text-editor popups) is
-     * the overlay's surface, so it must paint the overlay's registered elevation exactly —
+     * the overlay's surface, so it must paint the overlay's registered elevation exactly -
      * not stack a level above a parent surface. The elevation is read from the surface-context
      * tracker (the pane it renders into), which is authoritative across the portal boundary;
      * the panel's own declaration injector points back at the trigger location and cannot be
@@ -7841,7 +8129,7 @@ class AutoSurfaceDirective {
         ...(ngDevMode ? [{ debugName: "isOverlaySurface" }] : /* istanbul ignore next */ []));
         // Bumped by the afterEveryRender watcher in the constructor whenever this element's overlay
         // containment changes. surfaceForElement() below does a non-reactive element.contains() read,
-        // so the computed must be re-triggered when this element is (re)grafted into an overlay pane —
+        // so the computed must be re-triggered when this element is (re)grafted into an overlay pane -
         // otherwise a value cached from before the graft (one elevation too low) sticks forever.
         this.domSettleTick = signal(0, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "domSettleTick" }] : /* istanbul ignore next */ []));
@@ -7857,7 +8145,7 @@ class AutoSurfaceDirective {
             const contextElevation = contextProvider?.elevation() ?? null;
             const contextType = contextProvider?.surfaceType() ?? null;
             // An overlay's projected/portaled content keeps the injector of where it was
-            // *declared* (the trigger location), not the pane it renders into — so the
+            // *declared* (the trigger location), not the pane it renders into - so the
             // injector-derived parent surface is one elevation too low. The surface-context
             // tracker records each open overlay's surface *and* its pane element, so we consult
             // only the overlay whose pane actually contains this element in the DOM (portaling
@@ -7868,7 +8156,7 @@ class AutoSurfaceDirective {
             const overlayType = overlaySurface?.type ?? null;
             // A panel that IS its overlay's own surface (see matchOverlaySurface) must paint exactly the
             // overlay's elevation: the overlay container already resolved it (one above the trigger) and
-            // registered it in the tracker. It must NOT re-derive from its declaration injector — that
+            // registered it in the tracker. It must NOT re-derive from its declaration injector - that
             // points back at the trigger location and disagrees with the pane whenever the trigger itself
             // sits on a surface, which would double-elevate the panel relative to its own pane.
             if (this.isOverlaySurface()) {
@@ -7901,7 +8189,7 @@ class AutoSurfaceDirective {
         ...(ngDevMode ? [{ debugName: "resolvedSurface" }] : /* istanbul ignore next */ []));
         // Projected/portaled auto-surface content (e.g. a select option's avatar) can have its
         // resolvedSurface computed run *before* it is grafted into the overlay pane it visually lives
-        // in — or while it is briefly mounted in an off-pane measuring container, as windowed lists do.
+        // in - or while it is briefly mounted in an off-pane measuring container, as windowed lists do.
         // surfaceForElement()'s element.contains() check then returns the wrong (or no) overlay, so it
         // resolves off the declaration injector (the trigger location) one elevation too low. That check
         // is a plain DOM read, not a signal, so nothing re-runs the computed once the element reaches its
@@ -7918,14 +8206,13 @@ class AutoSurfaceDirective {
                 this.domSettleTick.update((v) => v + 1);
             }
             else if (el.isConnected && ++stableRenders >= 2) {
-                // containment has held for a couple of renders and the element is in the DOM — done moving
+                // containment has held for a couple of renders and the element is in the DOM - done moving
                 settleWatcher.destroy();
             }
         });
         effect(() => {
             const surface = this.resolvedSurface();
             untracked(() => {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 setInputSignal(this.ownSurfaceProvider.surface, surface);
             });
         });
@@ -7942,12 +8229,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
         }], ctorParameters: () => [], propDecorators: { surfaceProvider: [{ type: i0.Input, args: [{ isSignal: true, alias: "surfaceProvider", required: false }] }] } });
 
 const createCssColorThemeName = (name) => name.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
-const [ɵProvideColorThemes, injectColorThemes] = createStaticProvider(undefined, {
+const COLOR_THEMES_DEF = /* @__PURE__ */ defineStaticProvider(undefined, {
     name: 'Color Themes',
 });
-const [ɵProvideColorThemesPrefix, injectColorThemesPrefix] = createStaticProvider('et', {
+const ɵProvideColorThemes = /* @__PURE__ */ toProvideFn(COLOR_THEMES_DEF);
+const injectColorThemes = /* @__PURE__ */ toInjectFn(COLOR_THEMES_DEF);
+const COLOR_THEMES_PREFIX_DEF = /* @__PURE__ */ defineStaticProvider('et', {
     name: 'Themes Prefix',
 });
+const ɵProvideColorThemesPrefix = /* @__PURE__ */ toProvideFn(COLOR_THEMES_PREFIX_DEF);
+const injectColorThemesPrefix = /* @__PURE__ */ toInjectFn(COLOR_THEMES_PREFIX_DEF);
 const provideColorThemesWithTailwind4 = (themes, prefix = 'et') => [
     ɵProvideColorThemes(themes),
     ɵProvideColorThemesPrefix(prefix),
@@ -8166,7 +8457,7 @@ const COLOR_PROVIDER = new InjectionToken('ColorProvider');
  * The color provider attached to a bootstrapped root component (e.g. `ProvideColorDirective` in
  * the app component's `hostDirectives`), if any. Detached DOM such as overlay panes can't reach
  * it through element DI, so overlay containers fall back to this when resolving the provider to
- * `syncWithProvider()` — resolve at sync time, not at injection time, since root components only
+ * `syncWithProvider()` - resolve at sync time, not at injection time, since root components only
  * register with `ApplicationRef` once bootstrap completes.
  *
  * @internal
@@ -8180,7 +8471,7 @@ const resolveAppRootColorProvider = (appRef) => {
     }
     return null;
 };
-const FORCED_COLOR_UNSET = Symbol('FORCED_COLOR_UNSET');
+const FORCED_COLOR_UNSET = /* @__PURE__ */ Symbol('FORCED_COLOR_UNSET');
 class ProvideColorDirective {
     constructor() {
         this.themes = injectColorThemes({ optional: true });
@@ -8200,8 +8491,8 @@ class ProvideColorDirective {
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "effectiveColor" }] : /* istanbul ignore next */ []));
         /**
-         * The color that actually applies at this provider's location: its own effective color, or —
-         * when this provider is passive (no input, nothing forced) — the nearest ancestor provider's.
+         * The color that actually applies at this provider's location: its own effective color, or -
+         * when this provider is passive (no input, nothing forced) - the nearest ancestor provider's.
          * Mirrors the CSS cascade, which falls through a provider's `-color--inherited` scope class;
          * consumers that re-apply context across detached DOM (overlay panes) must use this instead
          * of `effectiveColor` or a passive in-between provider (e.g. a form field's) erases the theme.
@@ -8294,14 +8585,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
         }] });
 
 /**
- * Same shape as `ColorInteractiveDirective` — reacts to its own `:hover`/`:focus-visible`/
- * `:active`/`[disabled]` — but drives `--et-surface-interaction-*`, a neutral/muted tint, instead
+ * Same shape as `ColorInteractiveDirective` - reacts to its own `:hover`/`:focus-visible`/
+ * `:active`/`[disabled]` - but drives `--et-surface-interaction-*`, a neutral/muted tint, instead
  * of the ambient color theme. Use it for chrome-level interaction feedback that shouldn't borrow
  * the page's brand color (a tab trigger's hover state, a toggle button that should look neutral
- * until it's actually active — see `ButtonDirective`'s `mutedUntilPressed`).
+ * until it's actually active - see `ButtonDirective`'s `mutedUntilPressed`).
  *
  * Has no container/exclude/has-focus variants: it has no descendant-cascading CSS at all, so
- * applying it to a wrapper with independently-interactive children is safe by construction —
+ * applying it to a wrapper with independently-interactive children is safe by construction -
  * unlike `ColorInteractiveDirective`, there's no bubbling-leak failure mode to worry about here.
  */
 class SurfaceInteractiveDirective {
@@ -8322,6 +8613,81 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
+const UNSAVED_CHANGES_COORDINATOR_DEF = /* @__PURE__ */ defineRootProvider(() => {
+    const registrations = new Set();
+    const _isCheckPending = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_isCheckPending" }] : /* istanbul ignore next */ []));
+    let pending = null;
+    /** @internal Runs a tracker's confirm under the single-flight + abandon regime. */
+    const runCheck = (runner) => {
+        // A confirm is already on screen - adopt its answer rather than opening a second dialog.
+        if (pending) {
+            return pending.promise;
+        }
+        const controller = new AbortController();
+        let settle;
+        const abandoned = new Promise((resolve) => (settle = resolve));
+        // Run the confirm synchronously - a dialog that opens a microtask later can miss a `signal` that
+        // already aborted, and callers reasonably expect the dialog to be up when `runCheck()` returns.
+        let confirmed;
+        try {
+            confirmed = runner({ signal: controller.signal }).catch(() => false);
+        }
+        catch {
+            confirmed = Promise.resolve(false);
+        }
+        // Whichever settles first wins: a late answer from an abandoned confirm is ignored.
+        const promise = Promise.race([confirmed, abandoned]).then((result) => {
+            pending = null;
+            _isCheckPending.set(false);
+            return result;
+        });
+        pending = { promise, controller, settle };
+        _isCheckPending.set(true);
+        return promise;
+    };
+    /** @internal */
+    const register = (registration) => {
+        registrations.add(registration);
+        return () => registrations.delete(registration);
+    };
+    const abandonAll = (reason = 'session-end') => {
+        if (pending) {
+            pending.controller.abort(reason);
+            // The changes are unrecoverable at this point, so the discard is allowed: whatever waited on
+            // this check (an overlay close, a `canDeactivate`) proceeds instead of hanging.
+            pending.settle(true);
+        }
+        for (const registration of Array.from(registrations)) {
+            registration.abandon(reason);
+        }
+    };
+    return {
+        /** Whether a confirm is currently on screen. */
+        isCheckPending: _isCheckPending.asReadonly(),
+        abandonAll,
+        runCheck,
+        register,
+    };
+}, { name: 'Unsaved Changes Coordinator' });
+/**
+ * App-wide coordination for the unsaved-changes family. Two jobs:
+ *
+ * - **One confirm at a time.** A page form, an overlay form and a route guard can all want a decision
+ *   at once; stacking three "discard your changes?" dialogs is never the right answer. A check that
+ *   starts while another is pending adopts the pending decision instead of asking again.
+ * - **Abandoning guards when the session ends.** `abandonAll()` resolves the pending confirm, tells
+ *   its dialog to close (via {@link UnsavedChangesConfirmContext.signal}), and switches every live
+ *   guard off: further checks pass, and the tab locks release. Called automatically by
+ *   `@ethlete/query`'s auth provider on logout - the edits cannot be saved anymore, so guarding them
+ *   only strands dialogs over the login page and blocks the tab.
+ *
+ * Root-provided; every tracker registers itself. Inject it to abandon guards from app code (a session
+ * timeout of your own, a hard reset) or to read whether a confirm is currently on screen.
+ */
+const provideUnsavedChangesCoordinator = /* @__PURE__ */ toProvideFn(UNSAVED_CHANGES_COORDINATOR_DEF);
+const injectUnsavedChangesCoordinator = /* @__PURE__ */ toInjectFn(UNSAVED_CHANGES_COORDINATOR_DEF);
+
 const isAbstractControl = (value) => !!value &&
     typeof value === 'object' &&
     typeof value.getRawValue === 'function' &&
@@ -8337,13 +8703,13 @@ const normalizeUnsavedChangesSource = (source) => {
     if (isFieldTree(source)) {
         return {
             value: computed(() => source().value()),
-            // FieldTree's value type is a generic conditional that TS can't narrow here — cast the writer.
+            // FieldTree's value type is a generic conditional that TS can't narrow here - cast the writer.
             setValue: (next) => source().value.set(next),
         };
     }
     if (isSignal(source)) {
         const peek = untracked(source);
-        // A signal that currently holds a FieldTree — or nothing yet (the late/async form case).
+        // A signal that currently holds a FieldTree - or nothing yet (the late/async form case).
         if (peek === null || peek === undefined || isFieldTree(peek)) {
             const fieldSignal = source;
             return {
@@ -8368,6 +8734,179 @@ const normalizeUnsavedChangesSource = (source) => {
         'an AbstractControl, or a WritableSignal.');
 };
 
+/** The default tab title marker - a filled dot, prefixed while there are unsaved changes. */
+const UNSAVED_CHANGES_TITLE_MARKER = '●';
+// The badge is a single app-wide surface, so every lock that wants one registers here and the badge
+// is derived from all of them - otherwise the first tracker to go clean would clear a badge that
+// another one still needs.
+const BADGE_HOLDERS = /* @__PURE__ */ new Map();
+const syncAppBadge = () => {
+    const nav = typeof navigator === 'undefined' ? null : navigator;
+    if (!nav?.setAppBadge || !nav.clearAppBadge) {
+        return;
+    }
+    // Unsupported, or not installed - the promise rejects instead of throwing synchronously.
+    const ignore = () => undefined;
+    if (!BADGE_HOLDERS.size) {
+        nav.clearAppBadge().catch(ignore);
+        return;
+    }
+    const count = Array.from(BADGE_HOLDERS.values()).reduce((total, contents) => (typeof contents === 'number' ? total + contents : total), 0);
+    // `setAppBadge()` without a count renders a plain dot.
+    nav.setAppBadge(count || undefined).catch(ignore);
+};
+/**
+ * The browser-tab flavor of the unsaved-changes family: while `hasChanges` reads `true`, the tab
+ * cannot be closed or reloaded without the browser's confirm prompt, and - opt in - the tab title
+ * carries a marker (optionally blinking), the favicon carries a dot, and the installed app carries a
+ * badge.
+ *
+ * Every {@link createUnsavedChangesTracker} sets this up automatically (lock only); reach for it
+ * directly when you track "unsaved" state that isn't a form, or want to lock the tab from a signal
+ * you already have. Call from an injection context.
+ *
+ * ```ts
+ * createUnsavedChangesTabLock({
+ *   hasChanges: computed(() => this.uploads().some((u) => u.pending)),
+ *   titleMarker: true,
+ *   flash: true,
+ * });
+ * ```
+ */
+const createUnsavedChangesTabLock = (config) => {
+    assertInInjectionContext(createUnsavedChangesTabLock);
+    const { hasChanges } = config;
+    const lock = config.lock ?? true;
+    const flash = config.flash === true ? {} : config.flash || null;
+    const favicon = config.favicon === true ? {} : config.favicon || null;
+    const badge = config.badge ?? false;
+    // Blinking needs something to blink, so it implies the default marker.
+    const titleMarker = config.titleMarker === true
+        ? UNSAVED_CHANGES_TITLE_MARKER
+        : (config.titleMarker ?? (flash && !favicon ? UNSAVED_CHANGES_TITLE_MARKER : null));
+    const destroyRef = inject(DestroyRef);
+    const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    const releaseFns = [];
+    // The blink phase. Always `true` unless flashing is on, so the marker/favicon effects below can read
+    // one signal either way.
+    const flashPhase = signal(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "flashPhase" }] : /* istanbul ignore next */ []));
+    if (isBrowser && flash) {
+        const interval = flash.interval ?? 1000;
+        const whenHidden = flash.whenHidden ?? true;
+        const isDocumentVisible = injectIsDocumentVisible();
+        const shouldFlash = computed(() => hasChanges() && (!whenHidden || !isDocumentVisible()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "shouldFlash" }] : /* istanbul ignore next */ []));
+        const flashEffect = effect((onCleanup) => {
+            if (!shouldFlash()) {
+                return;
+            }
+            const handle = setInterval(() => flashPhase.update((on) => !on), interval);
+            onCleanup(() => {
+                clearInterval(handle);
+                flashPhase.set(true);
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "flashEffect" }] : /* istanbul ignore next */ []));
+        releaseFns.push(() => {
+            flashEffect.destroy();
+            flashPhase.set(true);
+        });
+    }
+    /** Dirty, and in the "shown" half of a blink. */
+    const isMarked = computed(() => hasChanges() && flashPhase(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isMarked" }] : /* istanbul ignore next */ []));
+    if (titleMarker) {
+        const titleStore = injectTitleStore();
+        const markerId = Symbol('unsaved-changes-title-marker');
+        const markerEffect = effect(() => {
+            const marked = isMarked();
+            untracked(() => (marked ? titleStore.addMarker(markerId, titleMarker) : titleStore.removeMarker(markerId)));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "markerEffect" }] : /* istanbul ignore next */ []));
+        releaseFns.push(() => {
+            markerEffect.destroy();
+            titleStore.removeMarker(markerId);
+        });
+    }
+    if (isBrowser && favicon) {
+        const faviconStore = injectFaviconStore();
+        const overlayId = Symbol('unsaved-changes-favicon');
+        const faviconEffect = effect(() => {
+            const marked = isMarked();
+            untracked(() => marked
+                ? faviconStore.addOverlay(overlayId, { kind: 'dot', color: favicon.color })
+                : faviconStore.removeOverlay(overlayId));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "faviconEffect" }] : /* istanbul ignore next */ []));
+        releaseFns.push(() => {
+            faviconEffect.destroy();
+            faviconStore.removeOverlay(overlayId);
+        });
+    }
+    if (isBrowser && lock) {
+        const onBeforeUnload = (event) => {
+            event.preventDefault();
+            // Legacy Chrome / Safari gate the prompt on a truthy `returnValue` rather than on
+            // `preventDefault()`. Deprecated, but still the only way to reach those engines.
+            event.returnValue = true;
+        };
+        let attached = false;
+        const attach = () => {
+            if (attached)
+                return;
+            attached = true;
+            window.addEventListener('beforeunload', onBeforeUnload);
+        };
+        const detach = () => {
+            if (!attached)
+                return;
+            attached = false;
+            window.removeEventListener('beforeunload', onBeforeUnload);
+        };
+        // Attached only while there are changes: a permanently registered `beforeunload` listener makes
+        // the page ineligible for the back/forward cache, which would slow every back navigation.
+        const lockEffect = effect(() => {
+            const dirty = hasChanges();
+            untracked(() => (dirty ? attach() : detach()));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lockEffect" }] : /* istanbul ignore next */ []));
+        releaseFns.push(() => {
+            lockEffect.destroy();
+            detach();
+        });
+    }
+    if (isBrowser && badge !== false) {
+        const badgeId = Symbol('unsaved-changes-badge');
+        const contents = badge === true ? true : badge;
+        const badgeEffect = effect(() => {
+            const dirty = hasChanges();
+            untracked(() => {
+                if (dirty) {
+                    BADGE_HOLDERS.set(badgeId, contents);
+                }
+                else {
+                    BADGE_HOLDERS.delete(badgeId);
+                }
+                syncAppBadge();
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "badgeEffect" }] : /* istanbul ignore next */ []));
+        releaseFns.push(() => {
+            badgeEffect.destroy();
+            BADGE_HOLDERS.delete(badgeId);
+            syncAppBadge();
+        });
+    }
+    const destroy = () => {
+        while (releaseFns.length) {
+            releaseFns.pop()?.();
+        }
+    };
+    destroyRef.onDestroy(destroy);
+    return { destroy };
+};
+
 const toBooleanPromise = (result) => {
     if (result instanceof Promise) {
         return result.then(Boolean);
@@ -8382,8 +8921,15 @@ const toBooleanPromise = (result) => {
  * whether the watched form/value differs from it, and runs an async confirm before a discard.
  * Call from an injection context (a field initializer or constructor).
  *
+ * While there are changes the browser tab is locked too (`beforeunload`), so closing or reloading the
+ * tab needs a confirmation - see the `tab` config for the title-marker / app-badge extras and for
+ * opting out.
+ *
+ * Every tracker registers with the app-wide {@link injectUnsavedChangesCoordinator}, which keeps a
+ * single confirm on screen at a time and switches all guards off when the session ends (logout).
+ *
  * Overlay and router flavors (`createOverlayUnsavedChangesGuard`, `createUnsavedChangesGuard`) build
- * on this — use them when you want the guard wired to a close/navigation event automatically.
+ * on this - use them when you want the guard wired to a close/navigation event automatically.
  */
 const createUnsavedChangesTracker = (config) => {
     assertInInjectionContext(createUnsavedChangesTracker);
@@ -8418,11 +8964,23 @@ const createUnsavedChangesTracker = (config) => {
         return !(compareFn ? compareFn(current, defaultValue) : equal(current, defaultValue));
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "hasChanges" }] : /* istanbul ignore next */ []));
+    const tab = config.tab === false ? null : createUnsavedChangesTabLock({ ...config.tab, hasChanges });
+    const coordinator = injectUnsavedChangesCoordinator();
+    const _isAbandoned = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_isAbandoned" }] : /* istanbul ignore next */ []));
+    const unregister = coordinator.register({
+        abandon: () => {
+            _isAbandoned.set(true);
+            // The session is gone: stop holding the tab hostage over edits that can no longer be saved.
+            tab?.destroy();
+        },
+    });
+    inject(DestroyRef).onDestroy(unregister);
     const runCheck = () => {
-        if (!untracked(hasChanges)) {
+        if (untracked(_isAbandoned) || !untracked(hasChanges)) {
             return Promise.resolve(true);
         }
-        return toBooleanPromise(confirm(untracked(normalized.value)));
+        return coordinator.runCheck((context) => toBooleanPromise(confirm(untracked(normalized.value), context)));
     };
     const refreshDefaultValue = () => _defaultValue.set(untracked(normalized.value));
     const restoreDefaultValue = () => {
@@ -8433,10 +8991,12 @@ const createUnsavedChangesTracker = (config) => {
     };
     return {
         hasChanges,
+        isAbandoned: _isAbandoned.asReadonly(),
         defaultValue: _defaultValue.asReadonly(),
         runCheck,
         refreshDefaultValue,
         restoreDefaultValue,
+        tab,
     };
 };
 
@@ -8459,5 +9019,5 @@ const createUnsavedChangesGuard = (config) => {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, ANIMATION_DEBUG_STORAGE_KEY, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, AutoSurfaceDirective, BOUNDARY_ELEMENT_TOKEN, BREAKPOINT_INSTANCE_TOKEN, BREAKPOINT_ORDER, COLOR_PROVIDER, ClickOutsideDirective, ColorInteractiveContainerDirective, ColorInteractiveDirective, ColorInteractiveExcludeDirective, ColorInteractiveHasFocusDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, DragHandleDirective, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUSABLE_SELECTOR, FOCUS_VISIBLE_TRACKER_TOKEN, HtmlToMarkdownPipe, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, InitialsPipe, IsArrayNotEmpty, IsEmail, jsonLd as JsonLD, KeyPressManager, MUST_MATCH, MarkdownToHtmlPipe, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideColorDirective, ProvideSurfaceDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeHandlesComponent, RuntimeError, SEO_DIRECTIVE_TOKEN, SURFACE_PROVIDER, SURFACE_TYPE, ScrollObserverDirective, ScrollObserverEndDirective, ScrollObserverStartDirective, SeoDirective, SlugifyPipe, StructuredDataComponent, SurfaceInteractiveDirective, ToArrayPipe, TypedQueryList, ValidateAtLeastOneRequired, Validators, animationDebugLog, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyCenteredPosition, applyDescriptionBinding, applyGlobalPosition, applyHeadBinding, applyHeadTitleBinding, applyHostListener, applyHostListeners, applyInitialFocus, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boolBreakpointTransform, booleanBreakpointAttribute, boundingClientRectToElementRect, breakpointTransformBase, buildElementSignal, buildSignalEffects, canUseSessionMemory, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, copyToClipboard, createAnchoredPositionCleanup, createArrayPropertyBinding, createAutoSessionMemoryKey, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssColorThemeName, createCssSurfaceName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createOverlayRuntimeRef, createPropHandlers, createPropertyBinding, createProps, createProvider, createRootProvider, createRootThemeCss, createRoute, createRouterState, createRxHostListener, createSessionMemory, createSetup, createStaticProvider, createStaticRootProvider, createSwatchCss, createSwipeTracker, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, createUnsavedChangesGuard, createUnsavedChangesTracker, createUserConsentProvider, deferredSignal, deleteCookie, dragGestureFrom, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, equal, firstElementSignal, focusElement, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFocusableElements, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getHeadingElement, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, getScrollContainerTarget, getScrollItemTarget, getScrollSnapTarget, hasCookie, holdScrollRestoration, htmlToMarkdown, inferMimeType, initials, injectAngularRootElement, injectAnimatedBlockSize, injectBoundaryElement, injectBreakpointInput, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectColorThemesPrefix, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectErrorTheme, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsDocumentVisible, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectOverlayRuntime, injectPathParam, injectPathParamChanges, injectPathParams, injectPrefersReducedMotion, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectStyleManager, injectSuccessTheme, injectSurfaceContextTracker, injectSurfaceThemes, injectSurfaceThemesPrefix, injectTemplateRef, injectTitleConfig, injectTitleStore, injectUrl, injectViewportConfig, injectViewportDimensions, injectViewportSize, injectWarningTheme, isAnimationDebugEnabled, isArray, isElementSignal, isElementVisible, isFocusable, isGroupMatch, isHTMLElement, isKnockoutMatch, isObject, markdownToHtml, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, normalizeUnsavedChangesSource, numberBreakpointAttribute, numberBreakpointTransform, previousSignalValue, provideBoundaryElement, provideBreakpointInstance, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideOverlayRuntime, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideStyleManager, provideSurfaceContextTracker, provideSurfaceThemesWithTailwind4, provideTitleConfig, provideTitleStore, provideViewportConfig, randomId, readFromClipboard, resetPositioningStyles, resolveAppRootColorProvider, resolveSurfaceByElevation, round, routerDisableScrollTop, scrollToElement, setBackdropStyles, setBaseElementStyles, setCookie, setInputSignal, setupFocusTrap, setupPositioning, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, slugify, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toStringBinding, transformOrReturn, typedBreakpointTransform, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideColorThemesPrefix, ɵProvideSurfaceThemes, ɵProvideSurfaceThemesPrefix };
+export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, ANIMATION_DEBUG_STORAGE_KEY, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AutoSurfaceDirective, BOUNDARY_ELEMENT_TOKEN, BREAKPOINT_INSTANCE_TOKEN, BREAKPOINT_ORDER, COLOR_PROVIDER, ClickOutsideDirective, ColorInteractiveContainerDirective, ColorInteractiveDirective, ColorInteractiveExcludeDirective, ColorInteractiveHasFocusDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, DragHandleDirective, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUSABLE_SELECTOR, FOCUS_VISIBLE_TRACKER_TOKEN, HtmlToMarkdownPipe, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, InitialsPipe, IsArrayNotEmpty, IsEmail, jsonLd as JsonLD, KeyPressManager, MUST_MATCH, MarkdownToHtmlPipe, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideColorDirective, ProvideSurfaceDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeHandlesComponent, RuntimeError, SEO_DIRECTIVE_TOKEN, SURFACE_PROVIDER, SURFACE_TYPE, SWIPE_VELOCITY_WINDOW_MS, ScrollObserverDirective, ScrollObserverEndDirective, ScrollObserverStartDirective, SeoDirective, SlugifyPipe, StructuredDataComponent, SurfaceInteractiveDirective, ToArrayPipe, TypedQueryList, UNSAVED_CHANGES_TITLE_MARKER, ValidateAtLeastOneRequired, Validators, anchoredOverlayPosition, animationDebugLog, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyCenteredPosition, applyDescriptionBinding, applyFaviconOverlay, applyGlobalPosition, applyHeadBinding, applyHeadTitleBinding, applyHeadTitleMarker, applyHostListener, applyHostListeners, applyInitialFocus, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boolBreakpointTransform, booleanBreakpointAttribute, boundingClientRectToElementRect, breakpointTransformBase, buildElementSignal, buildSignalEffects, canUseSessionMemory, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, copyToClipboard, createAnchoredPositionCleanup, createArrayPropertyBinding, createAutoSessionMemoryKey, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssColorThemeName, createCssSurfaceName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createOverlayRuntimeRef, createPropHandlers, createPropertyBinding, createProps, createRootThemeCss, createRoute, createRouterState, createRxHostListener, createSessionMemory, createSetup, createSwatchCss, createSwipeTracker, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, createUnsavedChangesGuard, createUnsavedChangesTabLock, createUnsavedChangesTracker, createUserConsentProvider, deferredSignal, defineLabels, defineProvider, defineRootProvider, defineStaticProvider, defineStaticRootProvider, deleteCookie, dragGestureFrom, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, enableAnchoredOverlayPositionExtras, equal, firstElementSignal, focusElement, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFocusableElements, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getHeadingElement, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, getScrollContainerTarget, getScrollItemTarget, getScrollSnapTarget, hasCookie, holdScrollRestoration, htmlToMarkdown, inferMimeType, initials, injectAngularRootElement, injectAnimatedBlockSize, injectBoundaryElement, injectBreakpointInput, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectColorThemesPrefix, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectErrorTheme, injectFaviconStore, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsDocumentVisible, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectOverlayRuntime, injectPathParam, injectPathParamChanges, injectPathParams, injectPrefersReducedMotion, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterNavigationState, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectStyleManager, injectSuccessTheme, injectSurfaceContextTracker, injectSurfaceThemes, injectSurfaceThemesPrefix, injectTemplateRef, injectTitleConfig, injectTitleStore, injectUnsavedChangesCoordinator, injectUrl, injectViewportConfig, injectViewportDimensions, injectViewportSize, injectWarningTheme, isAnimationDebugEnabled, isArray, isElementSignal, isElementVisible, isFocusable, isGroupMatch, isHTMLElement, isKnockoutMatch, isObject, markdownToHtml, matchesReducedMotion, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, normalizeUnsavedChangesSource, numberBreakpointAttribute, numberBreakpointTransform, previousSignalValue, provideBoundaryElement, provideBreakpointInstance, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFaviconStore, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideOverlayRuntime, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideStyleManager, provideSurfaceContextTracker, provideSurfaceThemesWithTailwind4, provideTitleConfig, provideTitleStore, provideUnsavedChangesCoordinator, provideViewportConfig, randomId, readFromClipboard, registerAnchoredPositionMiddlewareExtras, registerAnchoredPositionSetup, resetPositioningStyles, resolveAppRootColorProvider, resolveSurfaceByElevation, round, routerDisableScrollTop, scrollToElement, setBackdropStyles, setBaseElementStyles, setCookie, setInputSignal, setupFocusTrap, setupPositioning, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, slugify, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toInjectFn, toProvideFn, toStringBinding, toToken, transformOrReturn, typedBreakpointTransform, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideColorThemesPrefix, ɵProvideSurfaceThemes, ɵProvideSurfaceThemesPrefix };
 //# sourceMappingURL=ethlete-core.mjs.map