@tocdk-oss/ng-spotlight 0.0.0-stage → 21.0.0

package/fesm2022/tocdk-oss-ng-spotlight.mjs

@@ -0,0 +1,2085 @@
+import { Router } from '@angular/router';
+import { HttpClient } from '@angular/common/http';
+import { map, isObservable, catchError, of, from, Observable, filter, withLatestFrom, merge, switchMap, timeout, timer, startWith, shareReplay, combineLatest, Subject, BehaviorSubject, firstValueFrom } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, signal, isSignal, inject, Injector, computed, DestroyRef, Injectable, makeEnvironmentProviders, provideEnvironmentInitializer, EnvironmentInjector, input, ChangeDetectionStrategy, Component, ViewEncapsulation, TemplateRef, Directive, ViewContainerRef, viewChild, contentChildren, contentChild, effect, untracked, afterRenderEffect, afterNextRender } from '@angular/core';
+import { DOCUMENT, NgComponentOutlet, NgTemplateOutlet } from '@angular/common';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { Overlay } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+
+const ALLOWED_SCHEMES = new Set(['http', 'https', 'mailto', 'tel']);
+/**
+ * true for http(s), mailto, tel and path-relative URLs (`/x`, `./x`, `x`, `?q`, `#h`).
+ *
+ * - Browsers drop ASCII tab/newline and leading control characters before reading the scheme
+ *   ("java\nscript:" runs script), so those are removed before the check.
+ * - Protocol-relative URLs (`//host`, and `\\host` or `/\host`, since browsers read `\` as `/`
+ *   in http(s) URLs) point at another site, so they do not count as relative.
+ */
+function isSafeUrl(url) {
+    // What the browser parses: leading C0 controls and spaces stripped, tab/LF/CR removed anywhere.
+    const parsed = url.replace(/^[\u0000- \u007f]+/, '').replace(/[\t\n\r]/g, '');
+    if (/^[/\\]{2}/.test(parsed))
+        return false;
+    const compact = url.replace(/[\u0000- \u007f]/g, '');
+    const match = /^([a-z][a-z0-9+.-]*):/i.exec(compact);
+    return match === null || ALLOWED_SCHEMES.has(match[1].toLowerCase());
+}
+
+const BADGE_TONES = new Set(['info', 'success', 'warn', 'danger']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/** JSON data that reads back exactly as written: no undefined, functions, NaN or class instances. */
+function isJsonData(value, depth = 0) {
+    if (depth > 8)
+        return false;
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every((v) => isJsonData(v, depth + 1));
+    return isPlainObject(value) && Object.values(value).every((v) => isJsonData(v, depth + 1));
+}
+/**
+ * Route segments that survive storage: strings, finite numbers and plain JSON objects (matrix
+ * params such as `{ tab: 'orders' }`, or `{ outlets: … }`). The same rule decides what is saved
+ * and what is loaded back, so a saved route is never dropped on reload.
+ */
+function isRouteSegments(value) {
+    return (Array.isArray(value) &&
+        value.every((segment) => typeof segment === 'string' ||
+            (typeof segment === 'number' && Number.isFinite(segment)) ||
+            (isPlainObject(segment) && isJsonData(segment))));
+}
+function isBadge(value) {
+    if (!isRecord(value) || typeof value['label'] !== 'string')
+        return false;
+    const tone = value['tone'];
+    return tone === undefined || (typeof tone === 'string' && BADGE_TONES.has(tone));
+}
+/** Exactly one of route/url, each valid: unsafe URLs are dropped rather than replayed. */
+function isStoredAction(value) {
+    if (!isRecord(value))
+        return false;
+    const hasRoute = 'route' in value;
+    const hasUrl = 'url' in value;
+    if (hasRoute === hasUrl)
+        return false;
+    if (hasRoute)
+        return typeof value['route'] === 'string' || isRouteSegments(value['route']);
+    return typeof value['url'] === 'string' && isSafeUrl(value['url']);
+}
+function isRecentEntry(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value['id'] !== 'string' ||
+        typeof value['title'] !== 'string' ||
+        typeof value['group'] !== 'string' ||
+        typeof value['sourceId'] !== 'string') {
+        return false;
+    }
+    if (value['subtitle'] !== undefined && typeof value['subtitle'] !== 'string')
+        return false;
+    if (value['icon'] !== undefined && typeof value['icon'] !== 'string')
+        return false;
+    if (value['badges'] !== undefined && !(Array.isArray(value['badges']) && value['badges'].every(isBadge)))
+        return false;
+    return value['action'] === undefined || isStoredAction(value['action']);
+}
+/**
+ * Recent items in localStorage under `ng-spotlight:recent:<key>`. Every access is wrapped
+ * in try/catch, so the palette still works when storage is blocked, full or corrupted.
+ */
+function localStorageRecent(key) {
+    const storageKey = `ng-spotlight:recent:${key}`;
+    return {
+        load() {
+            try {
+                const raw = globalThis.localStorage?.getItem(storageKey);
+                if (!raw)
+                    return Promise.resolve([]);
+                const parsed = JSON.parse(raw);
+                return Promise.resolve(Array.isArray(parsed) ? parsed.filter(isRecentEntry) : []);
+            }
+            catch {
+                return Promise.resolve([]);
+            }
+        },
+        save(items) {
+            try {
+                globalThis.localStorage?.setItem(storageKey, JSON.stringify(items));
+            }
+            catch {
+                // Blocked or full storage: Recent simply isn't persisted.
+            }
+            return Promise.resolve();
+        },
+    };
+}
+/**
+ * Keeps only the fields needed to re-render the item and re-run a route or url action. A route
+ * array that would not survive JSON (a Date, a function, `undefined`, NaN, …) is stored by id
+ * only, like a run() item, and resolved through its source on the next load.
+ */
+function toRecentEntry(item, sourceId) {
+    const entry = { id: item.id, title: item.title, group: item.group, sourceId };
+    if (item.subtitle !== undefined)
+        entry.subtitle = item.subtitle;
+    if (item.icon !== undefined)
+        entry.icon = item.icon;
+    if (item.badges !== undefined)
+        entry.badges = item.badges;
+    const action = item.action;
+    if ('route' in action) {
+        if (typeof action.route === 'string' || isRouteSegments(action.route))
+            entry.action = { route: action.route };
+    }
+    else if ('url' in action)
+        entry.action = action.newTab ? { url: action.url, newTab: true } : { url: action.url };
+    return entry;
+}
+/** A stored route/url entry as an item; null for run() entries (resolve those through the source). */
+function entryToItem(entry) {
+    if (entry.action === undefined)
+        return null;
+    const item = { id: entry.id, title: entry.title, group: entry.group, action: entry.action };
+    if (entry.subtitle !== undefined)
+        item.subtitle = entry.subtitle;
+    if (entry.icon !== undefined)
+        item.icon = entry.icon;
+    if (entry.badges !== undefined)
+        item.badges = entry.badges;
+    return item;
+}
+/** Most recent first, unique per source + id, at most `max` entries. */
+function pushRecent(list, entry, max) {
+    const rest = list.filter((e) => !(e.id === entry.id && e.sourceId === entry.sourceId));
+    return [entry, ...rest].slice(0, Math.max(0, max));
+}
+
+/** Fixed commands. Results are local: the library ranks and filters them. */
+function staticSource(options) {
+    const seen = new Set();
+    const items = [];
+    for (const input of options.items) {
+        const item = { ...input, group: input.group ?? options.group };
+        // Ids must be unique per group; a later duplicate is dropped (as normalizeResult does).
+        const key = `${item.group}::${item.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        items.push(item);
+    }
+    return {
+        id: options.id ?? `static:${options.group}`,
+        group: options.group,
+        prefix: options.prefix,
+        priority: options.priority,
+        local: true,
+        search: () => items,
+    };
+}
+
+/** Depth-first walk of a Router config. Skips redirects, `**` and custom matchers. */
+function walkRoutes(routes, includeLazy, parentSegments = [], parentHasParam = false) {
+    const out = [];
+    for (const route of routes) {
+        if (route.path === '**' || route.redirectTo !== undefined || route.matcher !== undefined)
+            continue;
+        const segments = [...parentSegments, ...(route.path ?? '').split('/').filter((s) => s !== '')];
+        const hasParam = parentHasParam || segments.some((s) => s.startsWith(':'));
+        const data = route.data ?? {};
+        const spotlight = data['spotlight'];
+        const routeData = typeof spotlight === 'object' && spotlight !== null ? spotlight : {};
+        const breadcrumb = data['breadcrumb'];
+        const rawLabel = typeof route.title === 'string'
+            ? route.title
+            : typeof routeData.label === 'string'
+                ? routeData.label
+                : typeof breadcrumb === 'string'
+                    ? breadcrumb
+                    : null;
+        const children = route.children ?? (includeLazy ? route._loadedRoutes : undefined);
+        const rendersComponent = route.component !== undefined || route.loadComponent !== undefined;
+        out.push({
+            route,
+            url: '/' + segments.join('/'),
+            label: rawLabel !== null && rawLabel.trim() !== '' ? rawLabel : null,
+            keywords: Array.isArray(routeData.keywords)
+                ? routeData.keywords.filter((k) => typeof k === 'string')
+                : [],
+            suggested: routeData.suggested === true,
+            optedOut: spotlight === false,
+            hasParam,
+            isPage: rendersComponent && route.children === undefined && route.loadChildren === undefined,
+            routable: rendersComponent ||
+                (children ? children.some((child) => (child.path ?? '') === '') : route.loadChildren !== undefined),
+        });
+        if (children)
+            out.push(...walkRoutes(children, includeLazy, segments, hasParam));
+    }
+    return out;
+}
+
+/**
+ * Every labelled static route that is a page, including lazy children once loaded. A labelled
+ * parent that renders nothing at its own URL (no component, no empty-path child) is skipped;
+ * its labelled children still appear. A deeper route with the same URL (an empty-path child)
+ * wins over its parent. Results are local.
+ */
+function routeSource(options = {}) {
+    const group = options.group ?? 'Pages';
+    return {
+        id: options.id ?? 'routes',
+        group,
+        prefix: options.prefix,
+        priority: options.priority,
+        local: true,
+        search: (_query, ctx) => {
+            const router = ctx.injector.get(Router);
+            const byUrl = new Map();
+            for (const entry of walkRoutes(router.config, true)) {
+                if (entry.optedOut || entry.hasParam || entry.label === null || !entry.routable)
+                    continue;
+                if (options.filter && !options.filter(entry.route, entry.url))
+                    continue;
+                byUrl.set(entry.url, {
+                    id: `route:${entry.url}`,
+                    title: entry.label,
+                    subtitle: entry.url,
+                    group,
+                    keywords: entry.keywords,
+                    suggested: entry.suggested,
+                    action: { route: entry.url },
+                });
+            }
+            return [...byUrl.values()];
+        },
+    };
+}
+
+/**
+ * Static pages that have no label (title, data.spotlight.label or data.breadcrumb) and are not
+ * opted out with data.spotlight: false. Synchronous: `loadChildren` is not followed, so pass
+ * lazy route arrays in directly. A page whose URL a labelled parent already covers passes.
+ *
+ *     expect(spotlightRouteAudit(adminRoutes)).toEqual([]);
+ */
+function spotlightRouteAudit(routes, options = {}) {
+    const walked = walkRoutes(routes, false);
+    const labelledUrls = new Set(walked.filter((w) => w.label !== null).map((w) => w.url));
+    return walked
+        .filter((w) => w.isPage && !w.hasParam && !w.optedOut && w.label === null && !labelledUrls.has(w.url))
+        .filter((w) => !(options.ignore?.(w.route, w.url) ?? false))
+        .map((w) => ({ path: w.url, reason: 'missing-label' }));
+}
+
+class SpotlightResultError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SpotlightResultError';
+    }
+}
+function isSpotlightResponse(value) {
+    return typeof value === 'object' && value !== null && Array.isArray(value.groups);
+}
+function isValidAction(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const action = value;
+    return (typeof action['route'] === 'string' ||
+        Array.isArray(action['route']) ||
+        typeof action['url'] === 'string' ||
+        typeof action['run'] === 'function');
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isValidBadge(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const badge = value;
+    if (typeof badge['label'] !== 'string')
+        return false;
+    const tone = badge['tone'];
+    return tone === undefined || tone === 'info' || tone === 'success' || tone === 'warn' || tone === 'danger';
+}
+/**
+ * id and title are non-empty strings, the action is usable, optional fields have the right
+ * shape and the reserved `children` key is absent (even when its value is undefined).
+ */
+function isValidItem(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const item = value;
+    if (typeof item['id'] !== 'string' ||
+        item['id'] === '' ||
+        typeof item['title'] !== 'string' ||
+        !isValidAction(item['action']) ||
+        'children' in item) {
+        return false;
+    }
+    if (!isOptionalString(item['subtitle']) || !isOptionalString(item['icon']))
+        return false;
+    const keywords = item['keywords'];
+    if (keywords !== undefined && !(Array.isArray(keywords) && keywords.every((k) => typeof k === 'string'))) {
+        return false;
+    }
+    const badges = item['badges'];
+    if (badges !== undefined && !(Array.isArray(badges) && badges.every(isValidBadge)))
+        return false;
+    const suggested = item['suggested'];
+    return suggested === undefined || typeof suggested === 'boolean';
+}
+/** Optional item fields that JSON backends commonly send as `null` to mean "absent". */
+const NULLABLE_FIELDS = ['subtitle', 'icon', 'keywords', 'badges', 'suggested', 'data'];
+/** Strips `null` optional fields, then validates. Returns null for an invalid item. */
+function toItem(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    let candidate = value;
+    if (NULLABLE_FIELDS.some((key) => candidate[key] === null)) {
+        candidate = { ...candidate };
+        for (const key of NULLABLE_FIELDS)
+            if (candidate[key] === null)
+                delete candidate[key];
+    }
+    return isValidItem(candidate) ? candidate : null;
+}
+/**
+ * Turns whatever a source returned into validated groups. Invalid items and groups are
+ * dropped, `null` optional fields count as absent, and a later item whose `group::id` was
+ * already seen is dropped (ids must be unique per group). Grouped responses that repeat a
+ * group id merge into the first group with that id. A value that is not a result at all
+ * throws SpotlightResultError, which the engine turns into an error row for that source only.
+ */
+function normalizeResult(result, fallbackGroup) {
+    const byGroup = new Map();
+    const seen = new Set();
+    const add = (group, raw) => {
+        const item = toItem(raw);
+        if (item === null)
+            return;
+        const key = `${group.id}::${item.id}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        group.items.push({ ...item, group: group.id });
+    };
+    if (Array.isArray(result)) {
+        for (const raw of result) {
+            const rawGroup = raw?.group;
+            const id = typeof rawGroup === 'string' && rawGroup !== '' ? rawGroup : fallbackGroup;
+            let group = byGroup.get(id);
+            if (!group) {
+                group = { id, label: id, items: [] };
+                byGroup.set(id, group);
+            }
+            add(group, raw);
+        }
+        return [...byGroup.values()].filter((g) => g.items.length > 0);
+    }
+    if (isSpotlightResponse(result)) {
+        for (const rawGroup of result.groups) {
+            if (typeof rawGroup !== 'object' || rawGroup === null)
+                continue;
+            const g = rawGroup;
+            const id = g['id'];
+            if (typeof id !== 'string' || id === '')
+                continue;
+            let group = byGroup.get(id);
+            if (!group) {
+                group = { id, label: typeof g['label'] === 'string' ? g['label'] : id, items: [] };
+                const total = g['total'];
+                if (typeof total === 'number' && Number.isInteger(total) && total >= 0)
+                    group.total = total;
+                byGroup.set(id, group);
+            }
+            const rawItems = Array.isArray(g['items']) ? g['items'] : [];
+            for (const raw of rawItems)
+                add(group, raw);
+        }
+        return [...byGroup.values()];
+    }
+    throw new SpotlightResultError('[ng-spotlight] a source returned something that is neither SpotlightItem[] nor { groups: SpotlightGroup[] }');
+}
+
+/** Global request/map defaults for httpSource. Provided by provideSpotlight({ http }). */
+const SPOTLIGHT_HTTP_DEFAULTS = new InjectionToken('SPOTLIGHT_HTTP_DEFAULTS');
+
+function defaultRequest(query, ctx) {
+    return { method: 'GET', params: ctx.chip !== null ? { q: query, chip: ctx.chip } : { q: query } };
+}
+/**
+ * Remote results in the server's order. Default request: GET {url}?q={query}[&chip={groupId}].
+ * Default response: SpotlightResponse or SpotlightItem[]. Per-source request/map win over
+ * provideSpotlight({ http }), which wins over the defaults.
+ */
+function httpSource(options) {
+    const { url, request, map: map$1, ...given } = options;
+    // An explicit `undefined` (e.g. `minLength: config.minLength`) must not override a default.
+    const rest = Object.fromEntries(Object.entries(given).filter(([, value]) => value !== undefined));
+    const defaultMap = (response) => {
+        if (Array.isArray(response) || isSpotlightResponse(response))
+            return response;
+        throw new Error(`[ng-spotlight] httpSource ${url}: response is neither SpotlightResponse nor SpotlightItem[]`);
+    };
+    return {
+        minLength: 2,
+        debounceMs: 150,
+        local: false,
+        ...rest,
+        id: rest.id ?? `http:${url}`,
+        search: (query, ctx) => {
+            const globals = ctx.injector.get(SPOTLIGHT_HTTP_DEFAULTS, {});
+            const req = (request ?? globals.request ?? defaultRequest)(query, ctx);
+            const toResult = map$1 ?? globals.map ?? defaultMap;
+            return ctx.injector
+                .get(HttpClient)
+                .request(req.method ?? 'GET', url, {
+                params: req.params,
+                headers: req.headers,
+                body: req.body,
+                responseType: 'json',
+            })
+                .pipe(map((response) => toResult(response, query)));
+        },
+    };
+}
+
+const WORD_BOUNDARY = /[\s\-_/.:,()[\]]/;
+/** Score bonus for items that are in Recent. Smaller than the gap between match tiers. */
+const RECENT_BOOST = 50;
+/**
+ * 1000 exact, 800 start of text, 600 start of a word, 200–300 subsequence (tighter is higher),
+ * -1 no match, 0 for the empty query.
+ */
+function scoreText(text, query) {
+    if (query === '')
+        return 0;
+    const t = text.toLowerCase();
+    const q = query.toLowerCase();
+    if (t === q)
+        return 1000;
+    if (t.startsWith(q))
+        return 800;
+    for (let i = t.indexOf(q, 1); i > 0; i = t.indexOf(q, i + 1)) {
+        if (WORD_BOUNDARY.test(t[i - 1]))
+            return 600;
+    }
+    let pos = -1;
+    let first = -1;
+    for (const ch of q) {
+        pos = t.indexOf(ch, pos + 1);
+        if (pos === -1)
+            return -1;
+        if (first === -1)
+            first = pos;
+    }
+    const gaps = pos - first + 1 - q.length;
+    return 200 + Math.max(0, 100 - gaps);
+}
+/** Title score, or half the best keyword score, plus the Recent boost. null = no match. */
+function scoreItem(item, query, recentIds) {
+    let best = scoreText(item.title, query);
+    for (const keyword of item.keywords ?? []) {
+        const score = scoreText(keyword, query);
+        if (score >= 0)
+            best = Math.max(best, score / 2);
+    }
+    if (best < 0)
+        return null;
+    return best + (recentIds.has(item.id) ? RECENT_BOOST : 0);
+}
+/** Filters and sorts local results. Stable: equal scores keep the source's order. */
+function rankItems(items, query, recentIds = new Set()) {
+    if (query === '')
+        return [...items];
+    return items
+        .map((item, index) => ({ item, index, score: scoreItem(item, query, recentIds) }))
+        .filter((entry) => entry.score !== null)
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((entry) => entry.item);
+}
+
+const SPOTLIGHT_TEXT_KEYS = [
+    'placeholder',
+    'all',
+    'recent',
+    'noResults',
+    'loading',
+    'error',
+    'retry',
+    'hintNavigate',
+    'hintOpen',
+    'hintClose',
+];
+const DEFAULT_SPOTLIGHT_TEXTS = {
+    placeholder: 'Search…',
+    all: 'All',
+    recent: 'Recent',
+    noResults: 'No results',
+    loading: 'Loading…',
+    error: 'Something went wrong',
+    retry: 'Retry',
+    hintNavigate: 'to navigate',
+    hintOpen: 'to open',
+    hintClose: 'to close',
+    resultsAnnouncement: (count) => (count === 0 ? 'No results' : count === 1 ? '1 result' : `${count} results`),
+};
+function toTextSignal(value, fallback, injector) {
+    if (value === undefined)
+        return signal(fallback).asReadonly();
+    if (isSignal(value))
+        return value;
+    // An erroring source keeps the fallback; without this, toSignal rethrows on every read.
+    if (isObservable(value)) {
+        return toSignal(value.pipe(catchError(() => of(fallback))), { initialValue: fallback, injector });
+    }
+    return signal(value).asReadonly();
+}
+/** Every text becomes a Signal<string>; Observables are subscribed for the injector's lifetime. */
+function resolveTexts(texts, injector) {
+    const resolved = {};
+    for (const key of SPOTLIGHT_TEXT_KEYS) {
+        resolved[key] = toTextSignal(texts?.[key], DEFAULT_SPOTLIGHT_TEXTS[key], injector);
+    }
+    return {
+        ...resolved,
+        resultsAnnouncement: texts?.resultsAnnouncement ?? DEFAULT_SPOTLIGHT_TEXTS.resultsAnnouncement,
+    };
+}
+
+const DEFAULT_TIMEOUT_MS = 5000;
+const IDLE = { groups: [], loading: false, error: null };
+function planQuery(sources, raw) {
+    const trimmed = raw.trim();
+    const prefixed = sources
+        .filter((reg) => typeof reg.source.prefix === 'string' && reg.source.prefix !== '')
+        .sort((a, b) => b.source.prefix.length - a.source.prefix.length);
+    for (const reg of prefixed) {
+        const prefix = reg.source.prefix;
+        if (trimmed.startsWith(prefix))
+            return { query: trimmed.slice(prefix.length).trim(), only: reg.source };
+    }
+    return { query: trimmed, only: null };
+}
+function sortSources(sources) {
+    return [...sources].sort((a, b) => (a.source.priority ?? a.order) - (b.source.priority ?? b.order) || a.order - b.order);
+}
+function toObservableResult(result) {
+    if (isObservable(result))
+        return result;
+    if (typeof result.then === 'function')
+        return from(result);
+    return of(result);
+}
+function knownGroups(learned, source) {
+    let known = learned.get(source.id);
+    if (!known) {
+        known = new Map(source.group ? [[source.group, source.group]] : []);
+        learned.set(source.id, known);
+    }
+    return known;
+}
+/** Calls search() with a fresh AbortSignal that is aborted if the call is superseded. */
+function callSource(reg, query, chip) {
+    return new Observable((subscriber) => {
+        const controller = new AbortController();
+        let finished = false;
+        let inner;
+        try {
+            inner = toObservableResult(reg.source.search(query, { signal: controller.signal, chip, injector: reg.injector })).subscribe({
+                next: (value) => subscriber.next(value),
+                error: (error) => {
+                    finished = true;
+                    subscriber.error(error);
+                },
+                complete: () => {
+                    finished = true;
+                    subscriber.complete();
+                },
+            });
+        }
+        catch (error) {
+            finished = true;
+            subscriber.error(error);
+        }
+        return () => {
+            if (!finished)
+                controller.abort();
+            inner?.unsubscribe();
+        };
+    });
+}
+function runSource(reg, all, input$, options, learned) {
+    const source = reg.source;
+    let last = [];
+    const retried$ = options.retry$.pipe(filter((id) => id === source.id), withLatestFrom(input$), map(([, state]) => state));
+    return merge(input$, retried$).pipe(switchMap((state) => {
+        const plan = planQuery(all, state.query);
+        const known = knownGroups(learned, source);
+        const eligible = (plan.only === null || plan.only === source) &&
+            (state.chip === null || known.has(state.chip)) &&
+            plan.query.length >= (source.minLength ?? 0);
+        if (!eligible) {
+            last = [];
+            return of(IDLE);
+        }
+        const browseAll = plan.only !== null;
+        const result$ = callSource(reg, plan.query, state.chip).pipe(timeout({ first: source.timeoutMs ?? DEFAULT_TIMEOUT_MS }), map((result) => {
+            let groups = normalizeResult(result, source.group ?? source.id);
+            for (const g of groups)
+                known.set(g.id, g.label);
+            if (state.chip !== null)
+                groups = groups.filter((g) => g.id === state.chip);
+            if (source.local === true && plan.query !== '') {
+                const recent = options.recentIds(source.id);
+                groups = groups.map((g) => ({ ...g, items: rankItems(g.items, plan.query, recent) }));
+            }
+            if (plan.query === '' && !browseAll) {
+                groups = groups.map((g) => ({ ...g, items: g.items.filter((i) => i.suggested === true) }));
+            }
+            groups = groups.filter((g) => g.items.length > 0);
+            last = groups;
+            return { groups, loading: false, error: null };
+        }), catchError((error) => {
+            last = [];
+            try {
+                options.onError(error, source);
+            }
+            catch {
+                // a throwing consumer callback must not take down other groups
+            }
+            return of({ groups: [], loading: false, error });
+        }));
+        const debounceMs = source.debounceMs ?? 0;
+        const delayed$ = debounceMs > 0 ? timer(debounceMs).pipe(switchMap(() => result$)) : result$;
+        return delayed$.pipe(startWith({ groups: last, loading: true, error: null }));
+    }));
+}
+function toGroupStates(reg, state, learned, placeholderLabel) {
+    const source = reg.source;
+    if (state.groups.length > 0) {
+        return state.groups.map((g) => ({
+            key: `${source.id}::${g.id}`,
+            id: g.id,
+            label: g.label,
+            ...(g.total !== undefined ? { total: g.total } : {}),
+            sourceId: source.id,
+            items: g.items,
+            loading: state.loading,
+            error: null,
+        }));
+    }
+    if (!state.loading && state.error === null)
+        return [];
+    // Placeholder header (spinner or error row) in the source's usual group. A group-less
+    // source that never answered gets a neutral label, never its internal id.
+    const known = learned.get(source.id);
+    const id = source.group ?? (known && known.size > 0 ? [...known.keys()][0] : source.id);
+    return [
+        {
+            key: `${source.id}::${id}`,
+            id,
+            label: known?.get(id) ?? placeholderLabel(state.error === null ? 'loading' : 'error'),
+            sourceId: source.id,
+            items: [],
+            loading: state.loading,
+            error: state.error,
+        },
+    ];
+}
+/** Streams the grouped results for every query emitted on input$ (spec §5). */
+function createSearchEngine(options) {
+    const sources = sortSources(options.sources);
+    if (sources.length === 0)
+        return of([]);
+    const learned = options.learned ?? new Map();
+    const placeholderLabel = options.placeholderLabel ?? ((state) => DEFAULT_SPOTLIGHT_TEXTS[state]);
+    const input$ = options.input$.pipe(shareReplay({ bufferSize: 1, refCount: true }));
+    return combineLatest(sources.map((reg) => runSource(reg, sources, input$, options, learned).pipe(map((state) => toGroupStates(reg, state, learned, placeholderLabel))))).pipe(map((lists) => lists.flat()));
+}
+
+const DEFAULT_HOTKEYS = ['ctrl.space', 'mod.k'];
+const MODIFIERS = new Set(['ctrl', 'alt', 'shift', 'meta', 'mod']);
+const KEY_ALIASES = {
+    space: ' ',
+    slash: '/',
+    period: '.',
+    comma: ',',
+    dash: '-',
+    esc: 'escape',
+    escape: 'escape',
+    enter: 'enter',
+};
+/** Parses 'ctrl.space', 'mod.k', 'alt.shift.slash', … 'mod' = Cmd on macOS, Ctrl elsewhere. */
+function parseHotkey(spec, isMac) {
+    const parts = spec.toLowerCase().split('.').filter((p) => p !== '');
+    const key = parts.pop();
+    if (key === undefined)
+        throw new Error(`[ng-spotlight] invalid hotkey "${spec}"`);
+    for (const modifier of parts) {
+        if (!MODIFIERS.has(modifier))
+            throw new Error(`[ng-spotlight] unknown modifier "${modifier}" in hotkey "${spec}"`);
+    }
+    const mods = new Set(parts);
+    return {
+        ctrl: mods.has('ctrl') || (mods.has('mod') && !isMac),
+        alt: mods.has('alt'),
+        shift: mods.has('shift'),
+        meta: mods.has('meta') || (mods.has('mod') && isMac),
+        key: KEY_ALIASES[key] ?? key,
+    };
+}
+function matchesHotkey(event, hotkey) {
+    if (event.isComposing)
+        return false;
+    // Autofill and synthetic keydown events can arrive without a key string.
+    if (typeof event.key !== 'string')
+        return false;
+    if (event.ctrlKey !== hotkey.ctrl ||
+        event.altKey !== hotkey.alt ||
+        event.shiftKey !== hotkey.shift ||
+        event.metaKey !== hotkey.meta) {
+        return false;
+    }
+    const key = event.key.toLowerCase();
+    if (hotkey.key === ' ')
+        return key === ' ' || event.code === 'Space';
+    if (key === hotkey.key)
+        return true;
+    // On macOS, Alt changes event.key (Alt+P gives 'π'); compare the physical key instead.
+    if (/^[a-z]$/.test(hotkey.key))
+        return event.code === `Key${hotkey.key.toUpperCase()}`;
+    if (/^[0-9]$/.test(hotkey.key))
+        return event.code === `Digit${hotkey.key}`;
+    return false;
+}
+function detectMac() {
+    return typeof navigator !== 'undefined' && /Mac|iPhone|iPad|iPod/.test(navigator.userAgent);
+}
+
+const RECENT_GROUP_ID = '__recent';
+/**
+ * How long select() waits for a run() action before it closes the palette anyway (spec §5.9:
+ * run() is awaited, then the palette closes). A run() that settles later still records Recent and
+ * emits `selected` (or reports its error); it never locks the palette.
+ */
+const RUN_WAIT_MS = 5000;
+let nextInstanceId = 0;
+/** Settings only the first (root or isolated) provideSpotlight() call may set. */
+const IGNORED_IN_CHILD = ['hotkeys', 'texts', 'recent', 'theme', 'onError'];
+const defaultOnError = (error, source) => {
+    console.error(`[ng-spotlight] source "${source.id}" failed`, error);
+};
+function parseHotkeys(specs) {
+    const isMac = detectMac();
+    return specs.map((spec) => parseHotkey(spec, isMac));
+}
+function chipsFrom(groups) {
+    const seen = new Map();
+    for (const group of groups) {
+        if (group.items.length > 0 && !seen.has(group.id))
+            seen.set(group.id, group.label);
+    }
+    return [...seen].map(([id, label]) => ({ id, label }));
+}
+/**
+ * State and behaviour of one palette. Provided by provideSpotlight(); never providedIn root.
+ * Deliberately has no ngOnDestroy: a child injector re-provides the parent's instance and
+ * must not destroy it. Cleanup runs through the creating injector's DestroyRef.
+ */
+class SpotlightService {
+    document = inject(DOCUMENT);
+    router = inject(Router, { optional: true });
+    regs = signal([], ...(ngDevMode ? [{ debugName: "regs" }] : /* istanbul ignore next */ []));
+    registrationOrder = 0;
+    configured = false;
+    /** Token of the select() whose action is still running; null when none is. */
+    selecting = null;
+    /** Incremented on every open(), so a late action never closes a palette opened after it. */
+    session = 0;
+    /** @internal Prefix for this instance's DOM ids. */
+    idPrefix = `sp-${nextInstanceId++}`;
+    _settings = {
+        hotkeys: parseHotkeys(DEFAULT_HOTKEYS),
+        theme: 'default',
+        recentMax: 8,
+        storage: localStorageRecent('default'),
+        onError: defaultOnError,
+    };
+    _texts = signal(resolveTexts(undefined, inject(Injector)), ...(ngDevMode ? [{ debugName: "_texts" }] : /* istanbul ignore next */ []));
+    _isOpen = signal(false, ...(ngDevMode ? [{ debugName: "_isOpen" }] : /* istanbul ignore next */ []));
+    isOpen = this._isOpen.asReadonly();
+    _query = signal('', ...(ngDevMode ? [{ debugName: "_query" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    query = this._query.asReadonly();
+    _chip = signal(null, ...(ngDevMode ? [{ debugName: "_chip" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    chip = this._chip.asReadonly();
+    _results = signal([], ...(ngDevMode ? [{ debugName: "_results" }] : /* istanbul ignore next */ []));
+    _recent = signal([], ...(ngDevMode ? [{ debugName: "_recent" }] : /* istanbul ignore next */ []));
+    _resolvedRuns = signal(new Map(), ...(ngDevMode ? [{ debugName: "_resolvedRuns" }] : /* istanbul ignore next */ []));
+    _activeKey = signal(null, ...(ngDevMode ? [{ debugName: "_activeKey" }] : /* istanbul ignore next */ []));
+    _chipGroups = signal([], ...(ngDevMode ? [{ debugName: "_chipGroups" }] : /* istanbul ignore next */ []));
+    selectedSubject = new Subject();
+    selected = this.selectedSubject.asObservable();
+    input$ = new BehaviorSubject({ query: '', chip: null });
+    retry$ = new Subject();
+    engine = null;
+    /** Group labels learned from answers; outlives the engine, which restarts on every open(). */
+    learnedGroups = new Map();
+    recentItems = computed(() => {
+        const runs = this._resolvedRuns();
+        const out = [];
+        for (const entry of this._recent()) {
+            const item = entryToItem(entry) ?? runs.get(`${entry.sourceId}::${entry.id}`) ?? null;
+            if (item)
+                out.push({ item, sourceId: entry.sourceId });
+        }
+        return out;
+    }, ...(ngDevMode ? [{ debugName: "recentItems" }] : /* istanbul ignore next */ []));
+    /** @internal Visible groups: Recent first on the empty query, then the sources' groups. */
+    groups = computed(() => {
+        const results = this._results();
+        if (this._query().trim() !== '' || this._chip() !== null)
+            return results;
+        const recent = this.recentItems();
+        if (recent.length === 0)
+            return results;
+        const recentKeys = new Set(recent.map((r) => `${r.sourceId}::${r.item.id}`));
+        const rest = results
+            .map((g) => ({ ...g, items: g.items.filter((i) => !recentKeys.has(`${g.sourceId}::${i.id}`)) }))
+            .filter((g) => g.items.length > 0 || g.loading || g.error !== null);
+        const recentGroup = {
+            key: RECENT_GROUP_ID,
+            id: RECENT_GROUP_ID,
+            label: this.texts.recent(),
+            sourceId: RECENT_GROUP_ID,
+            items: recent.map((r) => r.item),
+            loading: false,
+            error: null,
+        };
+        return [recentGroup, ...rest];
+    }, ...(ngDevMode ? [{ debugName: "groups" }] : /* istanbul ignore next */ []));
+    /** @internal Every selectable row in display order, including one retry row per failed source. */
+    options = computed(() => {
+        const out = [];
+        const recent = this.recentItems();
+        for (const group of this.groups()) {
+            if (group.error !== null) {
+                out.push({
+                    key: `retry::${group.sourceId}`,
+                    domId: `${this.idPrefix}-o${out.length}`,
+                    kind: 'retry',
+                    item: null,
+                    sourceId: group.sourceId,
+                    groupKey: group.key,
+                });
+                continue;
+            }
+            // A loading group still shows the previous query's rows; they must not be selectable.
+            if (group.loading)
+                continue;
+            group.items.forEach((item, index) => {
+                const sourceId = group.key === RECENT_GROUP_ID ? recent[index].sourceId : group.sourceId;
+                out.push({
+                    key: group.key === RECENT_GROUP_ID ? `${RECENT_GROUP_ID}::${sourceId}::${item.id}` : `${group.key}::${item.id}`,
+                    domId: `${this.idPrefix}-o${out.length}`,
+                    kind: 'item',
+                    item,
+                    sourceId,
+                    groupKey: group.key,
+                });
+            });
+        }
+        return out;
+    }, ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    activeIndex = computed(() => {
+        const options = this.options();
+        if (options.length === 0)
+            return -1;
+        const key = this._activeKey();
+        if (key === null)
+            return 0;
+        const index = options.findIndex((o) => o.key === key);
+        return index === -1 ? 0 : index;
+    }, ...(ngDevMode ? [{ debugName: "activeIndex" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    activeOption = computed(() => {
+        const index = this.activeIndex();
+        return index === -1 ? null : this.options()[index];
+    }, ...(ngDevMode ? [{ debugName: "activeOption" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    chips = computed(() => [{ id: null, label: this.texts.all() }, ...this._chipGroups()], ...(ngDevMode ? [{ debugName: "chips" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    loading = computed(() => this._results().some((g) => g.loading), ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    announcement = computed(() => {
+        const count = this.options().filter((o) => o.kind === 'item').length;
+        // Announce "Loading…" rather than "No results" while sources are still answering.
+        if (count === 0 && this.loading())
+            return this.texts.loading();
+        return this.texts.resultsAnnouncement(count);
+    }, ...(ngDevMode ? [{ debugName: "announcement" }] : /* istanbul ignore next */ []));
+    constructor() {
+        inject(DestroyRef).onDestroy(() => {
+            this.close();
+            this.selectedSubject.complete();
+        });
+    }
+    /** @internal */
+    get texts() {
+        return this._texts();
+    }
+    /** @internal */
+    get settings() {
+        return this._settings;
+    }
+    /** @internal Called by provideSpotlight(). The first call owns the settings; every call adds its sources. */
+    configure(config, injector) {
+        if (!this.configured) {
+            this.configured = true;
+            this._settings = {
+                hotkeys: parseHotkeys(config.hotkeys ?? DEFAULT_HOTKEYS),
+                theme: config.theme ?? 'default',
+                recentMax: config.recent?.max ?? 8,
+                storage: config.recent?.storage ?? localStorageRecent('default'),
+                onError: config.onError ?? defaultOnError,
+            };
+            this._texts.set(resolveTexts(config.texts, injector));
+        }
+        else if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            const ignored = IGNORED_IN_CHILD.filter((key) => config[key] !== undefined);
+            if (ignored.length > 0) {
+                console.warn(`[ng-spotlight] a child provideSpotlight() only adds sources and http defaults; ${ignored.join(', ')} ` +
+                    'ignored. Set them in the first provideSpotlight() call, or pass isolated: true for a separate palette.');
+            }
+        }
+        const added = (config.sources ?? []).map((source) => ({
+            source,
+            injector,
+            order: this.registrationOrder++,
+        }));
+        if (added.length === 0)
+            return;
+        this.regs.update((regs) => [...regs, ...added]);
+        injector.get(DestroyRef).onDestroy(() => {
+            this.regs.update((regs) => regs.filter((reg) => !added.includes(reg)));
+            const removed = new Set(added.map((reg) => reg.source.id));
+            const stillRegistered = new Set(this.regs().map((reg) => reg.source.id));
+            this._resolvedRuns.update((runs) => {
+                const next = new Map(runs);
+                for (const key of runs.keys()) {
+                    const sourceId = key.slice(0, key.indexOf('::'));
+                    if (removed.has(sourceId) && !stillRegistered.has(sourceId))
+                        next.delete(key);
+                }
+                return next;
+            });
+            this.restartEngine();
+        });
+        this.restartEngine();
+    }
+    open(query) {
+        if (this._isOpen()) {
+            if (query !== undefined)
+                this.setQuery(query);
+            return;
+        }
+        this._query.set(query ?? '');
+        this._chip.set(null);
+        this._activeKey.set(null);
+        this._chipGroups.set([]);
+        this.session++;
+        this._isOpen.set(true);
+        void this.loadRecent();
+        this.restartEngine();
+    }
+    close() {
+        if (!this._isOpen())
+            return;
+        this.selecting = null;
+        this._isOpen.set(false);
+        this.engine?.unsubscribe();
+        this.engine = null;
+        this._results.set([]);
+        this._query.set('');
+        this._chip.set(null);
+        this._activeKey.set(null);
+    }
+    /** @internal */
+    toggle() {
+        if (this._isOpen())
+            this.close();
+        else
+            this.open();
+    }
+    /** @internal */
+    setQuery(query) {
+        this._query.set(query);
+        this._activeKey.set(null);
+        this.input$.next({ query, chip: this._chip() });
+    }
+    /** @internal */
+    setChip(chip) {
+        this._chip.set(chip);
+        this._activeKey.set(null);
+        this.input$.next({ query: this._query(), chip });
+    }
+    /** @internal */
+    cycleChip(direction) {
+        const chips = this.chips();
+        if (chips.length < 2)
+            return;
+        const index = chips.findIndex((c) => c.id === this._chip());
+        this.setChip(chips[(index + direction + chips.length) % chips.length].id);
+    }
+    /** @internal */
+    moveActive(delta) {
+        const options = this.options();
+        if (options.length === 0)
+            return;
+        const n = options.length;
+        const next = (((this.activeIndex() + delta) % n) + n) % n;
+        this._activeKey.set(options[next].key);
+    }
+    /** @internal */
+    setActive(key) {
+        this._activeKey.set(key);
+    }
+    /** @internal */
+    retry(sourceId) {
+        this.retry$.next(sourceId);
+    }
+    /** @internal Runs the action, records Recent, closes and emits `selected` (spec §5.9). */
+    async select(option, modifiers = {}) {
+        if (option.kind === 'retry' || option.item === null) {
+            this.retry(option.sourceId);
+            return;
+        }
+        if (this.selecting !== null)
+            return;
+        const token = {};
+        this.selecting = token;
+        const session = this.session;
+        const item = option.item;
+        const source = this.regs().find((reg) => reg.source.id === option.sourceId)?.source ?? {
+            id: option.sourceId,
+            search: () => [],
+        };
+        const done = this.runAction(item.action, modifiers.newTab === true, source).then(() => null, (error) => ({ error }));
+        let timer;
+        const waited = new Promise((resolve) => (timer = setTimeout(() => resolve('waiting'), RUN_WAIT_MS)));
+        const first = await Promise.race([done, waited]);
+        clearTimeout(timer);
+        if (this.selecting === token)
+            this.selecting = null;
+        const finish = (outcome) => {
+            if (outcome === null)
+                this.remember(item, option.sourceId);
+            else
+                this.report(outcome.error, source);
+            // Don't close a palette the user opened again after this select().
+            if (this.session === session)
+                this.close();
+            if (outcome === null)
+                this.selectedSubject.next(item);
+        };
+        if (first !== 'waiting') {
+            finish(first);
+            return;
+        }
+        if (this.session === session)
+            this.close();
+        void done.then(finish);
+    }
+    async runAction(action, newTab, source) {
+        if ('run' in action) {
+            await action.run();
+            return;
+        }
+        if ('route' in action) {
+            const router = this.router;
+            if (!router)
+                throw new Error('[ng-spotlight] a route action needs provideRouter()');
+            const navigation = typeof action.route === 'string' ? router.navigateByUrl(action.route) : router.navigate(action.route);
+            void navigation.catch((error) => this.report(error, source));
+            return;
+        }
+        if (!isSafeUrl(action.url)) {
+            throw new Error(`[ng-spotlight] blocked a url with an unsafe scheme: ${JSON.stringify(action.url)}`);
+        }
+        const view = this.document.defaultView;
+        if (!view)
+            return;
+        if (action.newTab === true || newTab)
+            view.open(action.url, '_blank', 'noopener');
+        else
+            view.location.assign(action.url);
+    }
+    remember(item, sourceId) {
+        if ('run' in item.action) {
+            const key = `${sourceId}::${item.id}`;
+            this._resolvedRuns.update((runs) => new Map(runs).set(key, item));
+        }
+        const next = pushRecent(this._recent(), toRecentEntry(item, sourceId), this._settings.recentMax);
+        this._recent.set(next);
+        const storage = this._settings.storage;
+        void Promise.resolve()
+            .then(() => storage.save(next))
+            .catch((error) => console.warn('[ng-spotlight] could not save recent items', error));
+    }
+    async loadRecent() {
+        let loaded;
+        try {
+            loaded = await this._settings.storage.load();
+        }
+        catch (error) {
+            console.warn('[ng-spotlight] could not load recent items', error);
+            loaded = [];
+        }
+        const entries = Array.isArray(loaded)
+            ? loaded.filter(isRecentEntry).slice(0, this._settings.recentMax)
+            : [];
+        this._recent.set(entries);
+        await this.resolveRunEntries(entries);
+    }
+    /** run() entries are stored without an action; look them up in their source by id. */
+    async resolveRunEntries(entries) {
+        const pending = entries.filter((e) => e.action === undefined && !this._resolvedRuns().has(`${e.sourceId}::${e.id}`));
+        for (const sourceId of new Set(pending.map((e) => e.sourceId))) {
+            const reg = this.regs().find((r) => r.source.id === sourceId);
+            // Sources that need a query would be hit with an empty one just to open the palette.
+            if (!reg || (reg.source.minLength ?? 0) > 0)
+                continue;
+            try {
+                const result = await firstValueFrom(toObservableResult(reg.source.search('', { signal: new AbortController().signal, chip: null, injector: reg.injector })).pipe(timeout(reg.source.timeoutMs ?? DEFAULT_TIMEOUT_MS)));
+                const items = normalizeResult(result, reg.source.group ?? reg.source.id).flatMap((g) => g.items);
+                this._resolvedRuns.update((runs) => {
+                    const next = new Map(runs);
+                    for (const item of items)
+                        next.set(`${sourceId}::${item.id}`, item);
+                    return next;
+                });
+            }
+            catch {
+                // An unresolvable run() entry stays hidden.
+            }
+        }
+    }
+    restartEngine() {
+        if (!this._isOpen())
+            return;
+        this.engine?.unsubscribe();
+        this.input$ = new BehaviorSubject({ query: this._query(), chip: this._chip() });
+        this.engine = createSearchEngine({
+            sources: this.regs(),
+            input$: this.input$,
+            retry$: this.retry$,
+            recentIds: (sourceId) => new Set(this._recent().flatMap((entry) => (entry.sourceId === sourceId ? [entry.id] : []))),
+            onError: (error, source) => this.report(error, source),
+            learned: this.learnedGroups,
+            placeholderLabel: (state) => (state === 'loading' ? this.texts.loading() : this.texts.error()),
+        }).subscribe((groups) => {
+            this._results.set(groups);
+            if (this._chip() === null)
+                this._chipGroups.set(chipsFrom(groups));
+        });
+    }
+    report(error, source) {
+        try {
+            this._settings.onError(error, source);
+        }
+        catch (handlerError) {
+            console.error('[ng-spotlight] onError threw', handlerError);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+const SPOTLIGHT_LOCAL_CONFIG = new InjectionToken('SPOTLIGHT_LOCAL_CONFIG');
+/**
+ * Sets up a palette. Call it once in the app config; call it again in a child injector (for
+ * example a lazy route's `providers`) to add sources there. A child call only contributes
+ * `sources` and `http` defaults: its `texts`, `hotkeys`, `recent`, `theme` and `onError` are
+ * ignored (dev mode warns), since the first call owns the palette. Pass `isolated: true` for a
+ * separate palette with its own settings. Pass a factory to build the config in an injection
+ * context, e.g. `provideSpotlight(() => ({ texts: { placeholder: inject(I18n).t$('Search…') } }))`.
+ */
+function provideSpotlight(config = {}) {
+    return makeEnvironmentProviders([
+        { provide: SPOTLIGHT_LOCAL_CONFIG, useFactory: typeof config === 'function' ? config : () => config },
+        {
+            provide: SpotlightService,
+            useFactory: () => {
+                const local = inject(SPOTLIGHT_LOCAL_CONFIG);
+                const parent = local.isolated === true ? null : inject(SpotlightService, { skipSelf: true, optional: true });
+                return parent ?? new SpotlightService();
+            },
+        },
+        {
+            provide: SPOTLIGHT_HTTP_DEFAULTS,
+            useFactory: () => inject(SPOTLIGHT_LOCAL_CONFIG).http ?? inject(SPOTLIGHT_HTTP_DEFAULTS, { skipSelf: true, optional: true }) ?? {},
+        },
+        provideEnvironmentInitializer(() => {
+            inject(SpotlightService).configure(inject(SPOTLIGHT_LOCAL_CONFIG), inject(EnvironmentInjector));
+        }),
+    ]);
+}
+
+const SPOTLIGHT_RENDERER = new InjectionToken('SPOTLIGHT_RENDERER');
+
+class SpotlightDefaultInput {
+    ctx = input.required(...(ngDevMode ? [{ debugName: "ctx" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    onInput(event) {
+        this.ctx().onInput(event.target.value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultInput, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.25", type: SpotlightDefaultInput, isStandalone: true, selector: "spotlight-default-input", inputs: { ctx: { classPropertyName: "ctx", publicName: "ctx", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    <input
+      class="sp-input-el"
+      type="text"
+      role="combobox"
+      autocomplete="off"
+      spellcheck="false"
+      aria-autocomplete="list"
+      [id]="ctx().id"
+      [value]="ctx().value"
+      [attr.placeholder]="ctx().placeholder"
+      [attr.aria-label]="ctx().label"
+      [attr.aria-expanded]="ctx().expanded"
+      [attr.aria-controls]="ctx().controls"
+      [attr.aria-activedescendant]="ctx().activeDescendant"
+      (input)="onInput($event)"
+      (keydown)="ctx().onKeydown($event)"
+    />
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-default-input',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <input
+      class="sp-input-el"
+      type="text"
+      role="combobox"
+      autocomplete="off"
+      spellcheck="false"
+      aria-autocomplete="list"
+      [id]="ctx().id"
+      [value]="ctx().value"
+      [attr.placeholder]="ctx().placeholder"
+      [attr.aria-label]="ctx().label"
+      [attr.aria-expanded]="ctx().expanded"
+      [attr.aria-controls]="ctx().controls"
+      [attr.aria-activedescendant]="ctx().activeDescendant"
+      (input)="onInput($event)"
+      (keydown)="ctx().onKeydown($event)"
+    />
+  `,
+                }]
+        }], propDecorators: { ctx: [{ type: i0.Input, args: [{ isSignal: true, alias: "ctx", required: true }] }] } });
+class SpotlightDefaultChip {
+    ctx = input.required(...(ngDevMode ? [{ debugName: "ctx" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultChip, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.25", type: SpotlightDefaultChip, isStandalone: true, selector: "spotlight-default-chip", inputs: { ctx: { classPropertyName: "ctx", publicName: "ctx", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `<span class="sp-chip" [class.sp-chip-active]="ctx().active">{{ ctx().label }}</span>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultChip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-default-chip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `<span class="sp-chip" [class.sp-chip-active]="ctx().active">{{ ctx().label }}</span>`,
+                }]
+        }], propDecorators: { ctx: [{ type: i0.Input, args: [{ isSignal: true, alias: "ctx", required: true }] }] } });
+class SpotlightDefaultGroupHeader {
+    ctx = input.required(...(ngDevMode ? [{ debugName: "ctx" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultGroupHeader, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.25", type: SpotlightDefaultGroupHeader, isStandalone: true, selector: "spotlight-default-group-header", inputs: { ctx: { classPropertyName: "ctx", publicName: "ctx", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    <span class="sp-group-label">{{ ctx().label }}</span>
+    @if (ctx().total !== undefined) {
+      <!-- The separator keeps the group's accessible name readable: "Customers, 2". -->
+      <span style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0">, </span>
+      <span class="sp-group-total">{{ ctx().total }}</span>
+    }
+    @if (ctx().loading) {
+      <span class="sp-spinner" aria-hidden="true"></span>
+      @if (ctx().loadingText) {
+        <span
+          style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0"
+          >, {{ ctx().loadingText }}</span
+        >
+      }
+    }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultGroupHeader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-default-group-header',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <span class="sp-group-label">{{ ctx().label }}</span>
+    @if (ctx().total !== undefined) {
+      <!-- The separator keeps the group's accessible name readable: "Customers, 2". -->
+      <span style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0">, </span>
+      <span class="sp-group-total">{{ ctx().total }}</span>
+    }
+    @if (ctx().loading) {
+      <span class="sp-spinner" aria-hidden="true"></span>
+      @if (ctx().loadingText) {
+        <span
+          style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0"
+          >, {{ ctx().loadingText }}</span
+        >
+      }
+    }
+  `,
+                }]
+        }], propDecorators: { ctx: [{ type: i0.Input, args: [{ isSignal: true, alias: "ctx", required: true }] }] } });
+class SpotlightDefaultBadge {
+    ctx = input.required(...(ngDevMode ? [{ debugName: "ctx" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultBadge, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.25", type: SpotlightDefaultBadge, isStandalone: true, selector: "spotlight-default-badge", inputs: { ctx: { classPropertyName: "ctx", publicName: "ctx", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `<span class="sp-badge" [attr.data-tone]="ctx().badge.tone ?? 'info'">{{ ctx().badge.label }}</span>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-default-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `<span class="sp-badge" [attr.data-tone]="ctx().badge.tone ?? 'info'">{{ ctx().badge.label }}</span>`,
+                }]
+        }], propDecorators: { ctx: [{ type: i0.Input, args: [{ isSignal: true, alias: "ctx", required: true }] }] } });
+class SpotlightDefaultRow {
+    ctx = input.required(...(ngDevMode ? [{ debugName: "ctx" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    isImage(icon) {
+        return /^(https?:|data:image\/|\/|\.)/.test(icon);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultRow, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.25", type: SpotlightDefaultRow, isStandalone: true, selector: "spotlight-default-row", inputs: { ctx: { classPropertyName: "ctx", publicName: "ctx", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    @let item = ctx().item;
+    @if (item.icon) {
+      <span class="sp-icon" aria-hidden="true">
+        @if (isImage(item.icon)) {
+          <img [src]="item.icon" alt="" />
+        } @else {
+          <i [class]="item.icon"></i>
+        }
+      </span>
+    }
+    <span class="sp-text">
+      <span class="sp-title">{{ item.title }}</span>
+      @if (item.subtitle) {
+        <span class="sp-subtitle">{{ item.subtitle }}</span>
+      }
+    </span>
+    @if (item.badges?.length) {
+      <span class="sp-badges">
+        @for (badge of item.badges ?? []; track $index) {
+          <ng-container *ngComponentOutlet="ctx().badge; inputs: { ctx: { badge: badge } }" />
+        }
+      </span>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-default-row',
+                    imports: [NgComponentOutlet],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @let item = ctx().item;
+    @if (item.icon) {
+      <span class="sp-icon" aria-hidden="true">
+        @if (isImage(item.icon)) {
+          <img [src]="item.icon" alt="" />
+        } @else {
+          <i [class]="item.icon"></i>
+        }
+      </span>
+    }
+    <span class="sp-text">
+      <span class="sp-title">{{ item.title }}</span>
+      @if (item.subtitle) {
+        <span class="sp-subtitle">{{ item.subtitle }}</span>
+      }
+    </span>
+    @if (item.badges?.length) {
+      <span class="sp-badges">
+        @for (badge of item.badges ?? []; track $index) {
+          <ng-container *ngComponentOutlet="ctx().badge; inputs: { ctx: { badge: badge } }" />
+        }
+      </span>
+    }
+  `,
+                }]
+        }], propDecorators: { ctx: [{ type: i0.Input, args: [{ isSignal: true, alias: "ctx", required: true }] }] } });
+function resolveParts(renderer) {
+    return {
+        panelClass: renderer?.dialog?.panelClass ?? null,
+        backdropClass: renderer?.dialog?.backdropClass ?? null,
+        input: renderer?.input ?? SpotlightDefaultInput,
+        chips: renderer?.chips ?? SpotlightDefaultChip,
+        groupHeader: renderer?.groupHeader ?? SpotlightDefaultGroupHeader,
+        row: renderer?.row ?? SpotlightDefaultRow,
+        badge: renderer?.badge ?? SpotlightDefaultBadge,
+    };
+}
+
+/**
+ * Decides which palette reacts when several `<spotlight-host>`s listen for the same hotkey
+ * (for example the app shell's palette next to an `isolated` one), so one key press never opens
+ * two palettes or toggles a shared one twice. Exactly one palette reacts:
+ *
+ * 1. an open palette, so the hotkey closes it (the one opened last if several are open);
+ * 2. otherwise the palette opened most recently (by hotkey, trigger or `open()`);
+ * 3. before any palette has been opened, the `<spotlight-host>` created first, normally the
+ *    app shell's.
+ *
+ * Only palettes whose own hotkeys match the event take part. Internal; not exported.
+ */
+class SpotlightHotkeyArbiter {
+    clients = [];
+    clock = 0;
+    /** The decision for each event, so every host's listener for one key press agrees. */
+    decisions = new WeakMap();
+    register(client) {
+        this.clients.push(client);
+        return () => {
+            const index = this.clients.indexOf(client);
+            if (index !== -1)
+                this.clients.splice(index, 1);
+        };
+    }
+    opened(client) {
+        client.openedAt = ++this.clock;
+    }
+    /** The one palette that handles this hotkey event, or null when none listens for it. */
+    handler(event) {
+        const known = this.decisions.get(event);
+        if (known !== undefined)
+            return known;
+        const candidates = this.clients.filter((c) => c.hotkeys().some((hotkey) => matchesHotkey(event, hotkey)));
+        // Stable sort: equal openedAt (never opened) keeps creation order.
+        const latestFirst = (list) => [...list].sort((a, b) => b.openedAt - a.openedAt);
+        const choice = latestFirst(candidates.filter((c) => c.isOpen()))[0] ?? latestFirst(candidates)[0] ?? null;
+        this.decisions.set(event, choice);
+        return choice;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightHotkeyArbiter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightHotkeyArbiter, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightHotkeyArbiter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * The default theme: CSS variables only, light and dark. Variables sit on :where(:root)
+ * (zero specificity) so apps override them with a plain :root or pane-class rule. Every
+ * other rule is scoped under .sp-theme-default (set on the pane/backdrop by the host).
+ */
+const SPOTLIGHT_DEFAULT_CSS = `
+:where(:root) {
+  --sp-bg: #ffffff;
+  --sp-fg: #1f2328;
+  --sp-muted: #59636e;
+  --sp-accent: #0969da;
+  --sp-accent-fg: #ffffff;
+  --sp-active-bg: #ddf4ff;
+  --sp-border: #d1d9e0;
+  --sp-backdrop: rgba(31, 35, 40, 0.4);
+  --sp-radius: 12px;
+  --sp-font: system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
+  --sp-shadow: 0 16px 48px rgba(31, 35, 40, 0.24);
+  --sp-info: #0969da;
+  --sp-success: #1a7f37;
+  --sp-warn: #9a6700;
+  --sp-danger: #d1242f;
+}
+@media (prefers-color-scheme: dark) {
+  :where(:root:not(.sp-light)) {
+    --sp-bg: #151b23;
+    --sp-fg: #f0f6fc;
+    --sp-muted: #9198a1;
+    --sp-accent: #4493f8;
+    --sp-accent-fg: #0d1117;
+    --sp-active-bg: #1d2d44;
+    --sp-border: #3d444d;
+    --sp-backdrop: rgba(1, 4, 9, 0.6);
+    --sp-shadow: 0 16px 48px rgba(1, 4, 9, 0.6);
+    --sp-info: #4493f8;
+    --sp-success: #3fb950;
+    --sp-warn: #d29922;
+    --sp-danger: #f85149;
+  }
+}
+:where(.sp-dark) {
+  --sp-bg: #151b23;
+  --sp-fg: #f0f6fc;
+  --sp-muted: #9198a1;
+  --sp-accent: #4493f8;
+  --sp-accent-fg: #0d1117;
+  --sp-active-bg: #1d2d44;
+  --sp-border: #3d444d;
+  --sp-backdrop: rgba(1, 4, 9, 0.6);
+  --sp-shadow: 0 16px 48px rgba(1, 4, 9, 0.6);
+  --sp-info: #4493f8;
+  --sp-success: #3fb950;
+  --sp-warn: #d29922;
+  --sp-danger: #f85149;
+}
+.sp-backdrop.sp-theme-default { background: var(--sp-backdrop); }
+.sp-theme-default .sp-dialog {
+  box-sizing: border-box; display: flex; flex-direction: column; width: 100%; max-height: min(70vh, 640px);
+  background: var(--sp-bg); color: var(--sp-fg); font-family: var(--sp-font); font-size: 14px;
+  border: 1px solid var(--sp-border); border-radius: var(--sp-radius); box-shadow: var(--sp-shadow); overflow: hidden;
+}
+.sp-theme-default.sp-sheet .sp-dialog { height: 100%; max-height: none; border: 0; border-radius: 0; }
+.sp-theme-default .sp-input { display: flex; align-items: center; border-bottom: 1px solid var(--sp-border); }
+.sp-theme-default .sp-input:focus-within { box-shadow: inset 0 -2px 0 var(--sp-accent); }
+.sp-theme-default .sp-input-el {
+  flex: 1; min-width: 0; padding: 16px; border: 0; outline: none; background: transparent; color: inherit; font: inherit; font-size: 16px;
+}
+.sp-theme-default .sp-input-el::placeholder { color: var(--sp-muted); }
+.sp-theme-default .sp-chips { display: flex; flex-wrap: wrap; gap: 6px; padding: 8px 12px; border-bottom: 1px solid var(--sp-border); }
+.sp-theme-default .sp-chip-button { padding: 0; border: 0; background: none; color: inherit; font: inherit; cursor: pointer; border-radius: 999px; }
+.sp-theme-default .sp-chip { display: inline-block; padding: 2px 10px; border: 1px solid var(--sp-border); border-radius: 999px; color: var(--sp-muted); }
+.sp-theme-default .sp-chip-active { background: var(--sp-accent); border-color: var(--sp-accent); color: var(--sp-accent-fg); }
+.sp-theme-default .sp-list { flex: 1; overflow-y: auto; padding: 4px 0; outline: none; }
+.sp-theme-default .sp-group + .sp-group { border-top: 1px solid var(--sp-border); }
+.sp-theme-default .sp-group-header {
+  display: flex; align-items: center; gap: 8px; padding: 8px 16px 4px; color: var(--sp-muted);
+  font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.04em;
+}
+.sp-theme-default .sp-group-total { font-weight: 400; }
+.sp-theme-default .sp-option { display: flex; align-items: center; gap: 12px; padding: 8px 16px; cursor: pointer; }
+.sp-theme-default .sp-option[aria-selected='true'] { background: var(--sp-active-bg); box-shadow: inset 3px 0 0 var(--sp-accent); }
+.sp-theme-default .sp-icon { display: inline-flex; justify-content: center; width: 20px; color: var(--sp-muted); }
+.sp-theme-default .sp-icon img { width: 20px; height: 20px; object-fit: contain; }
+.sp-theme-default .sp-text { display: flex; flex: 1; flex-direction: column; min-width: 0; }
+.sp-theme-default .sp-title, .sp-theme-default .sp-subtitle { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.sp-theme-default .sp-subtitle { color: var(--sp-muted); font-size: 12px; }
+.sp-theme-default .sp-badges { display: inline-flex; gap: 4px; }
+.sp-theme-default .sp-badge { padding: 0 6px; background: var(--sp-bg); border: 1px solid currentColor; border-radius: 4px; font-size: 11px; line-height: 18px; color: var(--sp-info); }
+.sp-theme-default .sp-badge[data-tone='success'] { color: var(--sp-success); }
+.sp-theme-default .sp-badge[data-tone='warn'] { color: var(--sp-warn); }
+.sp-theme-default .sp-badge[data-tone='danger'] { color: var(--sp-danger); }
+.sp-theme-default .sp-error { flex: 1; color: var(--sp-muted); }
+.sp-theme-default .sp-retry { color: var(--sp-accent); text-decoration: underline; }
+.sp-theme-default .sp-empty { padding: 24px 16px; text-align: center; color: var(--sp-muted); }
+.sp-theme-default .sp-footer {
+  display: flex; flex-wrap: wrap; gap: 16px; padding: 8px 16px; border-top: 1px solid var(--sp-border); color: var(--sp-muted); font-size: 12px;
+}
+.sp-theme-default .sp-footer kbd { padding: 0 4px; border: 1px solid var(--sp-border); border-radius: 4px; font-family: inherit; }
+.sp-theme-default .sp-spinner {
+  width: 10px; height: 10px; border: 2px solid var(--sp-border); border-top-color: var(--sp-accent); border-radius: 50%;
+  animation: sp-spin 0.8s linear infinite;
+}
+@keyframes sp-spin { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) { .sp-theme-default .sp-spinner { animation: none; } }
+`;
+/** Rendered by <spotlight-host> only when theme is 'default'; theme 'none' never loads this CSS. */
+class SpotlightDefaultTheme {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultTheme, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.25", type: SpotlightDefaultTheme, isStandalone: true, selector: "spotlight-theme-default", host: { styleAttribute: "display:none" }, ngImport: i0, template: '', isInline: true, styles: [":where(:root){--sp-bg: #ffffff;--sp-fg: #1f2328;--sp-muted: #59636e;--sp-accent: #0969da;--sp-accent-fg: #ffffff;--sp-active-bg: #ddf4ff;--sp-border: #d1d9e0;--sp-backdrop: rgba(31, 35, 40, .4);--sp-radius: 12px;--sp-font: system-ui, -apple-system, \"Segoe UI\", Roboto, sans-serif;--sp-shadow: 0 16px 48px rgba(31, 35, 40, .24);--sp-info: #0969da;--sp-success: #1a7f37;--sp-warn: #9a6700;--sp-danger: #d1242f}@media(prefers-color-scheme:dark){:where(:root:not(.sp-light)){--sp-bg: #151b23;--sp-fg: #f0f6fc;--sp-muted: #9198a1;--sp-accent: #4493f8;--sp-accent-fg: #0d1117;--sp-active-bg: #1d2d44;--sp-border: #3d444d;--sp-backdrop: rgba(1, 4, 9, .6);--sp-shadow: 0 16px 48px rgba(1, 4, 9, .6);--sp-info: #4493f8;--sp-success: #3fb950;--sp-warn: #d29922;--sp-danger: #f85149}}:where(.sp-dark){--sp-bg: #151b23;--sp-fg: #f0f6fc;--sp-muted: #9198a1;--sp-accent: #4493f8;--sp-accent-fg: #0d1117;--sp-active-bg: #1d2d44;--sp-border: #3d444d;--sp-backdrop: rgba(1, 4, 9, .6);--sp-shadow: 0 16px 48px rgba(1, 4, 9, .6);--sp-info: #4493f8;--sp-success: #3fb950;--sp-warn: #d29922;--sp-danger: #f85149}.sp-backdrop.sp-theme-default{background:var(--sp-backdrop)}.sp-theme-default .sp-dialog{box-sizing:border-box;display:flex;flex-direction:column;width:100%;max-height:min(70vh,640px);background:var(--sp-bg);color:var(--sp-fg);font-family:var(--sp-font);font-size:14px;border:1px solid var(--sp-border);border-radius:var(--sp-radius);box-shadow:var(--sp-shadow);overflow:hidden}.sp-theme-default.sp-sheet .sp-dialog{height:100%;max-height:none;border:0;border-radius:0}.sp-theme-default .sp-input{display:flex;align-items:center;border-bottom:1px solid var(--sp-border)}.sp-theme-default .sp-input:focus-within{box-shadow:inset 0 -2px 0 var(--sp-accent)}.sp-theme-default .sp-input-el{flex:1;min-width:0;padding:16px;border:0;outline:none;background:transparent;color:inherit;font:inherit;font-size:16px}.sp-theme-default .sp-input-el::placeholder{color:var(--sp-muted)}.sp-theme-default .sp-chips{display:flex;flex-wrap:wrap;gap:6px;padding:8px 12px;border-bottom:1px solid var(--sp-border)}.sp-theme-default .sp-chip-button{padding:0;border:0;background:none;color:inherit;font:inherit;cursor:pointer;border-radius:999px}.sp-theme-default .sp-chip{display:inline-block;padding:2px 10px;border:1px solid var(--sp-border);border-radius:999px;color:var(--sp-muted)}.sp-theme-default .sp-chip-active{background:var(--sp-accent);border-color:var(--sp-accent);color:var(--sp-accent-fg)}.sp-theme-default .sp-list{flex:1;overflow-y:auto;padding:4px 0;outline:none}.sp-theme-default .sp-group+.sp-group{border-top:1px solid var(--sp-border)}.sp-theme-default .sp-group-header{display:flex;align-items:center;gap:8px;padding:8px 16px 4px;color:var(--sp-muted);font-size:12px;font-weight:600;text-transform:uppercase;letter-spacing:.04em}.sp-theme-default .sp-group-total{font-weight:400}.sp-theme-default .sp-option{display:flex;align-items:center;gap:12px;padding:8px 16px;cursor:pointer}.sp-theme-default .sp-option[aria-selected=true]{background:var(--sp-active-bg);box-shadow:inset 3px 0 0 var(--sp-accent)}.sp-theme-default .sp-icon{display:inline-flex;justify-content:center;width:20px;color:var(--sp-muted)}.sp-theme-default .sp-icon img{width:20px;height:20px;object-fit:contain}.sp-theme-default .sp-text{display:flex;flex:1;flex-direction:column;min-width:0}.sp-theme-default .sp-title,.sp-theme-default .sp-subtitle{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sp-theme-default .sp-subtitle{color:var(--sp-muted);font-size:12px}.sp-theme-default .sp-badges{display:inline-flex;gap:4px}.sp-theme-default .sp-badge{padding:0 6px;background:var(--sp-bg);border:1px solid currentColor;border-radius:4px;font-size:11px;line-height:18px;color:var(--sp-info)}.sp-theme-default .sp-badge[data-tone=success]{color:var(--sp-success)}.sp-theme-default .sp-badge[data-tone=warn]{color:var(--sp-warn)}.sp-theme-default .sp-badge[data-tone=danger]{color:var(--sp-danger)}.sp-theme-default .sp-error{flex:1;color:var(--sp-muted)}.sp-theme-default .sp-retry{color:var(--sp-accent);text-decoration:underline}.sp-theme-default .sp-empty{padding:24px 16px;text-align:center;color:var(--sp-muted)}.sp-theme-default .sp-footer{display:flex;flex-wrap:wrap;gap:16px;padding:8px 16px;border-top:1px solid var(--sp-border);color:var(--sp-muted);font-size:12px}.sp-theme-default .sp-footer kbd{padding:0 4px;border:1px solid var(--sp-border);border-radius:4px;font-family:inherit}.sp-theme-default .sp-spinner{width:10px;height:10px;border:2px solid var(--sp-border);border-top-color:var(--sp-accent);border-radius:50%;animation:sp-spin .8s linear infinite}@keyframes sp-spin{to{transform:rotate(360deg)}}@media(prefers-reduced-motion:reduce){.sp-theme-default .sp-spinner{animation:none}}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightDefaultTheme, decorators: [{
+            type: Component,
+            args: [{ selector: 'spotlight-theme-default', template: '', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: { style: 'display:none' }, styles: [":where(:root){--sp-bg: #ffffff;--sp-fg: #1f2328;--sp-muted: #59636e;--sp-accent: #0969da;--sp-accent-fg: #ffffff;--sp-active-bg: #ddf4ff;--sp-border: #d1d9e0;--sp-backdrop: rgba(31, 35, 40, .4);--sp-radius: 12px;--sp-font: system-ui, -apple-system, \"Segoe UI\", Roboto, sans-serif;--sp-shadow: 0 16px 48px rgba(31, 35, 40, .24);--sp-info: #0969da;--sp-success: #1a7f37;--sp-warn: #9a6700;--sp-danger: #d1242f}@media(prefers-color-scheme:dark){:where(:root:not(.sp-light)){--sp-bg: #151b23;--sp-fg: #f0f6fc;--sp-muted: #9198a1;--sp-accent: #4493f8;--sp-accent-fg: #0d1117;--sp-active-bg: #1d2d44;--sp-border: #3d444d;--sp-backdrop: rgba(1, 4, 9, .6);--sp-shadow: 0 16px 48px rgba(1, 4, 9, .6);--sp-info: #4493f8;--sp-success: #3fb950;--sp-warn: #d29922;--sp-danger: #f85149}}:where(.sp-dark){--sp-bg: #151b23;--sp-fg: #f0f6fc;--sp-muted: #9198a1;--sp-accent: #4493f8;--sp-accent-fg: #0d1117;--sp-active-bg: #1d2d44;--sp-border: #3d444d;--sp-backdrop: rgba(1, 4, 9, .6);--sp-shadow: 0 16px 48px rgba(1, 4, 9, .6);--sp-info: #4493f8;--sp-success: #3fb950;--sp-warn: #d29922;--sp-danger: #f85149}.sp-backdrop.sp-theme-default{background:var(--sp-backdrop)}.sp-theme-default .sp-dialog{box-sizing:border-box;display:flex;flex-direction:column;width:100%;max-height:min(70vh,640px);background:var(--sp-bg);color:var(--sp-fg);font-family:var(--sp-font);font-size:14px;border:1px solid var(--sp-border);border-radius:var(--sp-radius);box-shadow:var(--sp-shadow);overflow:hidden}.sp-theme-default.sp-sheet .sp-dialog{height:100%;max-height:none;border:0;border-radius:0}.sp-theme-default .sp-input{display:flex;align-items:center;border-bottom:1px solid var(--sp-border)}.sp-theme-default .sp-input:focus-within{box-shadow:inset 0 -2px 0 var(--sp-accent)}.sp-theme-default .sp-input-el{flex:1;min-width:0;padding:16px;border:0;outline:none;background:transparent;color:inherit;font:inherit;font-size:16px}.sp-theme-default .sp-input-el::placeholder{color:var(--sp-muted)}.sp-theme-default .sp-chips{display:flex;flex-wrap:wrap;gap:6px;padding:8px 12px;border-bottom:1px solid var(--sp-border)}.sp-theme-default .sp-chip-button{padding:0;border:0;background:none;color:inherit;font:inherit;cursor:pointer;border-radius:999px}.sp-theme-default .sp-chip{display:inline-block;padding:2px 10px;border:1px solid var(--sp-border);border-radius:999px;color:var(--sp-muted)}.sp-theme-default .sp-chip-active{background:var(--sp-accent);border-color:var(--sp-accent);color:var(--sp-accent-fg)}.sp-theme-default .sp-list{flex:1;overflow-y:auto;padding:4px 0;outline:none}.sp-theme-default .sp-group+.sp-group{border-top:1px solid var(--sp-border)}.sp-theme-default .sp-group-header{display:flex;align-items:center;gap:8px;padding:8px 16px 4px;color:var(--sp-muted);font-size:12px;font-weight:600;text-transform:uppercase;letter-spacing:.04em}.sp-theme-default .sp-group-total{font-weight:400}.sp-theme-default .sp-option{display:flex;align-items:center;gap:12px;padding:8px 16px;cursor:pointer}.sp-theme-default .sp-option[aria-selected=true]{background:var(--sp-active-bg);box-shadow:inset 3px 0 0 var(--sp-accent)}.sp-theme-default .sp-icon{display:inline-flex;justify-content:center;width:20px;color:var(--sp-muted)}.sp-theme-default .sp-icon img{width:20px;height:20px;object-fit:contain}.sp-theme-default .sp-text{display:flex;flex:1;flex-direction:column;min-width:0}.sp-theme-default .sp-title,.sp-theme-default .sp-subtitle{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sp-theme-default .sp-subtitle{color:var(--sp-muted);font-size:12px}.sp-theme-default .sp-badges{display:inline-flex;gap:4px}.sp-theme-default .sp-badge{padding:0 6px;background:var(--sp-bg);border:1px solid currentColor;border-radius:4px;font-size:11px;line-height:18px;color:var(--sp-info)}.sp-theme-default .sp-badge[data-tone=success]{color:var(--sp-success)}.sp-theme-default .sp-badge[data-tone=warn]{color:var(--sp-warn)}.sp-theme-default .sp-badge[data-tone=danger]{color:var(--sp-danger)}.sp-theme-default .sp-error{flex:1;color:var(--sp-muted)}.sp-theme-default .sp-retry{color:var(--sp-accent);text-decoration:underline}.sp-theme-default .sp-empty{padding:24px 16px;text-align:center;color:var(--sp-muted)}.sp-theme-default .sp-footer{display:flex;flex-wrap:wrap;gap:16px;padding:8px 16px;border-top:1px solid var(--sp-border);color:var(--sp-muted);font-size:12px}.sp-theme-default .sp-footer kbd{padding:0 4px;border:1px solid var(--sp-border);border-radius:4px;font-family:inherit}.sp-theme-default .sp-spinner{width:10px;height:10px;border:2px solid var(--sp-border);border-top-color:var(--sp-accent);border-radius:50%;animation:sp-spin .8s linear infinite}@keyframes sp-spin{to{transform:rotate(360deg)}}@media(prefers-reduced-motion:reduce){.sp-theme-default .sp-spinner{animation:none}}\n"] }]
+        }] });
+
+/** `<ng-template spotlightItem="customers" let-item>`: row for one group; without a value: for every group. */
+class SpotlightItemTemplate {
+    spotlightItem = input('', ...(ngDevMode ? [{ debugName: "spotlightItem" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    template = inject(TemplateRef);
+    static ngTemplateContextGuard(_dir, _ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightItemTemplate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.25", type: SpotlightItemTemplate, isStandalone: true, selector: "[spotlightItem]", inputs: { spotlightItem: { classPropertyName: "spotlightItem", publicName: "spotlightItem", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightItemTemplate, decorators: [{
+            type: Directive,
+            args: [{ selector: '[spotlightItem]' }]
+        }], propDecorators: { spotlightItem: [{ type: i0.Input, args: [{ isSignal: true, alias: "spotlightItem", required: false }] }] } });
+/** `<ng-template spotlightEmpty let-query>`: shown when a non-empty query has no results. */
+class SpotlightEmptyTemplate {
+    /** @internal */
+    template = inject(TemplateRef);
+    static ngTemplateContextGuard(_dir, _ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightEmptyTemplate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.25", type: SpotlightEmptyTemplate, isStandalone: true, selector: "[spotlightEmpty]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightEmptyTemplate, decorators: [{
+            type: Directive,
+            args: [{ selector: '[spotlightEmpty]' }]
+        }] });
+/** `<ng-template spotlightFooter>`: replaces the default key hints. */
+class SpotlightFooterTemplate {
+    /** @internal */
+    template = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightFooterTemplate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.25", type: SpotlightFooterTemplate, isStandalone: true, selector: "[spotlightFooter]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightFooterTemplate, decorators: [{
+            type: Directive,
+            args: [{ selector: '[spotlightFooter]' }]
+        }] });
+/** Opens the palette on click. `spotlightTrigger="#"` opens it with an initial query. */
+class SpotlightTrigger {
+    svc = inject(SpotlightService);
+    spotlightTrigger = input('', ...(ngDevMode ? [{ debugName: "spotlightTrigger" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    open() {
+        this.svc.open(this.spotlightTrigger() || undefined);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.25", type: SpotlightTrigger, isStandalone: true, selector: "[spotlightTrigger]", inputs: { spotlightTrigger: { classPropertyName: "spotlightTrigger", publicName: "spotlightTrigger", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "aria-haspopup": "dialog" }, listeners: { "click": "open()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[spotlightTrigger]',
+                    host: { '(click)': 'open()', 'aria-haspopup': 'dialog' },
+                }]
+        }], propDecorators: { spotlightTrigger: [{ type: i0.Input, args: [{ isSignal: true, alias: "spotlightTrigger", required: false }] }] } });
+
+const PHONE_QUERY = '(max-width: 600px)';
+/** The palette. Place it once in the app shell. */
+class SpotlightHost {
+    /** @internal */
+    svc = inject(SpotlightService);
+    overlay = inject(Overlay);
+    focusTrapFactory = inject(FocusTrapFactory);
+    breakpoints = inject(BreakpointObserver);
+    viewContainerRef = inject(ViewContainerRef);
+    injector = inject(Injector);
+    document = inject(DOCUMENT);
+    arbiter = inject(SpotlightHotkeyArbiter);
+    hotkeyClient = {
+        hotkeys: () => this.svc.settings.hotkeys,
+        isOpen: () => this.svc.isOpen(),
+        openedAt: 0,
+    };
+    /** @internal */
+    parts = resolveParts(inject(SPOTLIGHT_RENDERER, { optional: true }));
+    /** @internal */
+    themeDefault = this.svc.settings.theme === 'default';
+    /** @internal */
+    ids = {
+        prefix: this.svc.idPrefix,
+        input: `${this.svc.idPrefix}-input`,
+        listbox: `${this.svc.idPrefix}-listbox`,
+    };
+    panel = viewChild.required('panel');
+    itemTemplates = contentChildren(SpotlightItemTemplate, ...(ngDevMode ? [{ debugName: "itemTemplates" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    emptyTemplate = contentChild(SpotlightEmptyTemplate, ...(ngDevMode ? [{ debugName: "emptyTemplate" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    footerTemplate = contentChild(SpotlightFooterTemplate, ...(ngDevMode ? [{ debugName: "footerTemplate" }] : /* istanbul ignore next */ []));
+    overlayRef = null;
+    focusTrap = null;
+    restoreFocus = null;
+    /** @internal */
+    activeId = computed(() => this.svc.activeOption()?.domId ?? null, ...(ngDevMode ? [{ debugName: "activeId" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    optionsByGroup = computed(() => {
+        const byGroup = new Map();
+        for (const option of this.svc.options()) {
+            const list = byGroup.get(option.groupKey) ?? [];
+            list.push(option);
+            byGroup.set(option.groupKey, list);
+        }
+        return byGroup;
+    }, ...(ngDevMode ? [{ debugName: "optionsByGroup" }] : /* istanbul ignore next */ []));
+    /** @internal */
+    showEmpty = computed(() => this.svc.query().trim() !== '' && this.svc.options().length === 0 && !this.svc.loading(), ...(ngDevMode ? [{ debugName: "showEmpty" }] : /* istanbul ignore next */ []));
+    handleInput = (value) => this.svc.setQuery(value);
+    handleKeydown = (event) => this.onInputKeydown(event);
+    /** @internal */
+    inputCtx = computed(() => ({
+        id: this.ids.input,
+        value: this.svc.query(),
+        placeholder: this.texts.placeholder(),
+        label: this.texts.placeholder(),
+        expanded: this.svc.options().length > 0 || this.svc.loading(),
+        controls: this.ids.listbox,
+        activeDescendant: this.activeId(),
+        onInput: this.handleInput,
+        onKeydown: this.handleKeydown,
+    }), ...(ngDevMode ? [{ debugName: "inputCtx" }] : /* istanbul ignore next */ []));
+    constructor() {
+        const unregister = this.arbiter.register(this.hotkeyClient);
+        effect(() => {
+            const open = this.svc.isOpen();
+            untracked(() => {
+                if (open) {
+                    this.arbiter.opened(this.hotkeyClient);
+                    this.attach();
+                }
+                else {
+                    this.detach();
+                }
+            });
+        });
+        afterRenderEffect(() => {
+            const id = this.activeId();
+            if (id === null || this.overlayRef === null)
+                return;
+            this.document.getElementById(id)?.scrollIntoView?.({ block: 'nearest' });
+        });
+        inject(DestroyRef).onDestroy(() => {
+            unregister();
+            this.svc.close();
+            this.detach();
+        });
+    }
+    /** @internal */
+    get texts() {
+        return this.svc.texts;
+    }
+    /** @internal A placeholder header already reads "Loading…"; don't announce it twice. */
+    loadingTextFor(label) {
+        const loading = this.texts.loading();
+        return label === loading ? '' : loading;
+    }
+    /** @internal */
+    templateFor(groupId) {
+        const templates = this.itemTemplates();
+        const match = templates.find((t) => t.spotlightItem() === groupId) ?? templates.find((t) => t.spotlightItem() === '');
+        return match?.template ?? null;
+    }
+    /** @internal */
+    choose(option, event) {
+        void this.svc.select(option, { newTab: event.ctrlKey || event.metaKey });
+    }
+    /** @internal */
+    onDocumentKeydown(event) {
+        if (!this.svc.settings.hotkeys.some((hotkey) => matchesHotkey(event, hotkey)))
+            return;
+        event.preventDefault();
+        if (event.repeat)
+            return;
+        // With several palettes on the page, exactly one reacts (see SpotlightHotkeyArbiter).
+        if (this.arbiter.handler(event) !== this.hotkeyClient)
+            return;
+        this.svc.toggle();
+    }
+    onInputKeydown(event) {
+        if (event.isComposing)
+            return;
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.svc.moveActive(1);
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.svc.moveActive(-1);
+                break;
+            case 'Enter': {
+                event.preventDefault();
+                const option = this.svc.activeOption();
+                if (option)
+                    void this.svc.select(option, { newTab: event.ctrlKey || event.metaKey });
+                break;
+            }
+            case 'Tab':
+                if (this.svc.chips().length > 1) {
+                    event.preventDefault();
+                    this.svc.cycleChip(event.shiftKey ? -1 : 1);
+                }
+                break;
+        }
+    }
+    attach() {
+        if (this.overlayRef)
+            return;
+        const active = this.document.activeElement;
+        this.restoreFocus = active instanceof HTMLElement ? active : null;
+        const sheet = this.breakpoints.isMatched(PHONE_QUERY);
+        const theme = this.themeDefault ? ['sp-theme-default'] : [];
+        const position = this.overlay.position().global();
+        const ref = this.overlay.create({
+            hasBackdrop: true,
+            backdropClass: ['sp-backdrop', ...theme, ...(this.parts.backdropClass ? [this.parts.backdropClass] : [])],
+            panelClass: ['sp-pane', ...theme, ...(sheet ? ['sp-sheet'] : []), ...(this.parts.panelClass ? [this.parts.panelClass] : [])],
+            positionStrategy: sheet ? position.top('0').left('0') : position.centerHorizontally().top('12vh'),
+            scrollStrategy: this.overlay.scrollStrategies.block(),
+            width: sheet ? '100vw' : 'min(640px, calc(100vw - 32px))',
+            height: sheet ? '100dvh' : undefined,
+        });
+        ref.attach(new TemplatePortal(this.panel(), this.viewContainerRef));
+        ref.backdropClick().subscribe(() => this.svc.close());
+        ref.keydownEvents().subscribe((event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                this.svc.close();
+            }
+        });
+        this.focusTrap = this.focusTrapFactory.create(ref.overlayElement);
+        this.overlayRef = ref;
+        afterNextRender(() => this.overlayRef?.overlayElement.querySelector('[role="combobox"]')?.focus(), {
+            injector: this.injector,
+        });
+    }
+    detach() {
+        if (!this.overlayRef)
+            return;
+        this.focusTrap?.destroy();
+        this.focusTrap = null;
+        this.overlayRef.dispose();
+        this.overlayRef = null;
+        const target = this.restoreFocus;
+        this.restoreFocus = null;
+        if (target?.isConnected)
+            target.focus();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightHost, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.25", type: SpotlightHost, isStandalone: true, selector: "spotlight-host", host: { listeners: { "document:keydown": "onDocumentKeydown($event)" } }, queries: [{ propertyName: "itemTemplates", predicate: SpotlightItemTemplate, isSignal: true }, { propertyName: "emptyTemplate", first: true, predicate: SpotlightEmptyTemplate, descendants: true, isSignal: true }, { propertyName: "footerTemplate", first: true, predicate: SpotlightFooterTemplate, descendants: true, isSignal: true }], viewQueries: [{ propertyName: "panel", first: true, predicate: ["panel"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    @if (themeDefault) {
+      <spotlight-theme-default />
+    }
+    <ng-template #panel>
+      <div class="sp-dialog" role="dialog" aria-modal="true" [attr.aria-label]="texts.placeholder()">
+        <div class="sp-input">
+          <ng-container *ngComponentOutlet="parts.input; inputs: { ctx: inputCtx() }" />
+        </div>
+        @if (svc.chips().length > 1) {
+          <div class="sp-chips">
+            @for (chip of svc.chips(); track chip.id ?? '') {
+              <button
+                type="button"
+                class="sp-chip-button"
+                tabindex="-1"
+                [attr.aria-pressed]="chip.id === svc.chip()"
+                [attr.aria-label]="chip.label"
+                (mousedown)="$event.preventDefault()"
+                (click)="svc.setChip(chip.id)"
+              >
+                <ng-container
+                  *ngComponentOutlet="parts.chips; inputs: { ctx: { label: chip.label, active: chip.id === svc.chip() } }"
+                />
+              </button>
+            }
+          </div>
+        }
+        <div class="sp-list" role="listbox" tabindex="-1" [attr.aria-busy]="svc.loading() || null" [id]="ids.listbox" [attr.aria-label]="texts.placeholder()">
+          @for (group of svc.groups(); track group.key; let g = $index) {
+            <div class="sp-group" role="group" [attr.aria-labelledby]="ids.prefix + '-g' + g">
+              <div class="sp-group-header" [id]="ids.prefix + '-g' + g">
+                <ng-container
+                  *ngComponentOutlet="
+                    parts.groupHeader;
+                    inputs: { ctx: { label: group.label, total: group.total, loading: group.loading, loadingText: loadingTextFor(group.label) } }
+                  "
+                />
+              </div>
+              @for (opt of optionsByGroup().get(group.key) ?? []; track opt.key) {
+                <div
+                  class="sp-option"
+                  role="option"
+                  [id]="opt.domId"
+                  [attr.aria-selected]="opt.domId === activeId()"
+                  (mousedown)="$event.preventDefault()"
+                  (mousemove)="svc.setActive(opt.key)"
+                  (click)="choose(opt, $event)"
+                >
+                  @if (opt.item; as item) {
+                    @let rowTemplate = templateFor(item.group);
+                    @if (rowTemplate) {
+                      <ng-container
+                        *ngTemplateOutlet="rowTemplate; context: { $implicit: item, active: opt.domId === activeId(), query: svc.query() }"
+                      />
+                    } @else {
+                      <ng-container
+                        *ngComponentOutlet="
+                          parts.row;
+                          inputs: { ctx: { item: item, active: opt.domId === activeId(), query: svc.query(), badge: parts.badge } }
+                        "
+                      />
+                    }
+                  } @else {
+                    <span class="sp-error">{{ texts.error() }}</span>
+                    <span class="sp-retry">{{ texts.retry() }}</span>
+                  }
+                </div>
+              }
+            </div>
+          }
+        </div>
+        @if (showEmpty()) {
+          <div class="sp-empty">
+            @if (emptyTemplate(); as empty) {
+              <ng-container *ngTemplateOutlet="empty.template; context: { $implicit: svc.query() }" />
+            } @else {
+              {{ texts.noResults() }}
+            }
+          </div>
+        }
+        <div class="sp-footer">
+          @if (footerTemplate(); as footer) {
+            <ng-container *ngTemplateOutlet="footer.template" />
+          } @else {
+            <span><kbd>↑</kbd><kbd>↓</kbd> {{ texts.hintNavigate() }}</span>
+            <span><kbd>↵</kbd> {{ texts.hintOpen() }}</span>
+            <span><kbd>esc</kbd> {{ texts.hintClose() }}</span>
+          }
+        </div>
+        <div
+          role="status"
+          aria-live="polite"
+          style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0"
+        >
+          {{ svc.announcement() }}
+        </div>
+      </div>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: SpotlightDefaultTheme, selector: "spotlight-theme-default" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SpotlightHost, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'spotlight-host',
+                    imports: [NgComponentOutlet, NgTemplateOutlet, SpotlightDefaultTheme],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { '(document:keydown)': 'onDocumentKeydown($event)' },
+                    template: `
+    @if (themeDefault) {
+      <spotlight-theme-default />
+    }
+    <ng-template #panel>
+      <div class="sp-dialog" role="dialog" aria-modal="true" [attr.aria-label]="texts.placeholder()">
+        <div class="sp-input">
+          <ng-container *ngComponentOutlet="parts.input; inputs: { ctx: inputCtx() }" />
+        </div>
+        @if (svc.chips().length > 1) {
+          <div class="sp-chips">
+            @for (chip of svc.chips(); track chip.id ?? '') {
+              <button
+                type="button"
+                class="sp-chip-button"
+                tabindex="-1"
+                [attr.aria-pressed]="chip.id === svc.chip()"
+                [attr.aria-label]="chip.label"
+                (mousedown)="$event.preventDefault()"
+                (click)="svc.setChip(chip.id)"
+              >
+                <ng-container
+                  *ngComponentOutlet="parts.chips; inputs: { ctx: { label: chip.label, active: chip.id === svc.chip() } }"
+                />
+              </button>
+            }
+          </div>
+        }
+        <div class="sp-list" role="listbox" tabindex="-1" [attr.aria-busy]="svc.loading() || null" [id]="ids.listbox" [attr.aria-label]="texts.placeholder()">
+          @for (group of svc.groups(); track group.key; let g = $index) {
+            <div class="sp-group" role="group" [attr.aria-labelledby]="ids.prefix + '-g' + g">
+              <div class="sp-group-header" [id]="ids.prefix + '-g' + g">
+                <ng-container
+                  *ngComponentOutlet="
+                    parts.groupHeader;
+                    inputs: { ctx: { label: group.label, total: group.total, loading: group.loading, loadingText: loadingTextFor(group.label) } }
+                  "
+                />
+              </div>
+              @for (opt of optionsByGroup().get(group.key) ?? []; track opt.key) {
+                <div
+                  class="sp-option"
+                  role="option"
+                  [id]="opt.domId"
+                  [attr.aria-selected]="opt.domId === activeId()"
+                  (mousedown)="$event.preventDefault()"
+                  (mousemove)="svc.setActive(opt.key)"
+                  (click)="choose(opt, $event)"
+                >
+                  @if (opt.item; as item) {
+                    @let rowTemplate = templateFor(item.group);
+                    @if (rowTemplate) {
+                      <ng-container
+                        *ngTemplateOutlet="rowTemplate; context: { $implicit: item, active: opt.domId === activeId(), query: svc.query() }"
+                      />
+                    } @else {
+                      <ng-container
+                        *ngComponentOutlet="
+                          parts.row;
+                          inputs: { ctx: { item: item, active: opt.domId === activeId(), query: svc.query(), badge: parts.badge } }
+                        "
+                      />
+                    }
+                  } @else {
+                    <span class="sp-error">{{ texts.error() }}</span>
+                    <span class="sp-retry">{{ texts.retry() }}</span>
+                  }
+                </div>
+              }
+            </div>
+          }
+        </div>
+        @if (showEmpty()) {
+          <div class="sp-empty">
+            @if (emptyTemplate(); as empty) {
+              <ng-container *ngTemplateOutlet="empty.template; context: { $implicit: svc.query() }" />
+            } @else {
+              {{ texts.noResults() }}
+            }
+          </div>
+        }
+        <div class="sp-footer">
+          @if (footerTemplate(); as footer) {
+            <ng-container *ngTemplateOutlet="footer.template" />
+          } @else {
+            <span><kbd>↑</kbd><kbd>↓</kbd> {{ texts.hintNavigate() }}</span>
+            <span><kbd>↵</kbd> {{ texts.hintOpen() }}</span>
+            <span><kbd>esc</kbd> {{ texts.hintClose() }}</span>
+          }
+        </div>
+        <div
+          role="status"
+          aria-live="polite"
+          style="position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0"
+        >
+          {{ svc.announcement() }}
+        </div>
+      </div>
+    </ng-template>
+  `,
+                }]
+        }], ctorParameters: () => [], propDecorators: { panel: [{ type: i0.ViewChild, args: ['panel', { isSignal: true }] }], itemTemplates: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => SpotlightItemTemplate), { isSignal: true }] }], emptyTemplate: [{ type: i0.ContentChild, args: [i0.forwardRef(() => SpotlightEmptyTemplate), { isSignal: true }] }], footerTemplate: [{ type: i0.ContentChild, args: [i0.forwardRef(() => SpotlightFooterTemplate), { isSignal: true }] }] } });
+
+// Public API for @tocdk-oss/ng-spotlight. Every change here must show up in api/ng-spotlight.api.md
+// (npm run check:api). Members tagged internal in their JSDoc are stripped from the published .d.ts.
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SPOTLIGHT_RENDERER, SpotlightDefaultBadge, SpotlightDefaultChip, SpotlightDefaultGroupHeader, SpotlightDefaultInput, SpotlightDefaultRow, SpotlightEmptyTemplate, SpotlightFooterTemplate, SpotlightHost, SpotlightItemTemplate, SpotlightService, SpotlightTrigger, httpSource, localStorageRecent, provideSpotlight, routeSource, spotlightRouteAudit, staticSource };
+//# sourceMappingURL=tocdk-oss-ng-spotlight.mjs.map