npm - @mk-kit/ui - Versions diffs - 0.34.0 - Mend

@mk-kit/ui 0.34.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

package/LICENSE +21 -0
package/README.md +115 -0
package/block-editor/README.md +254 -0
package/fesm2022/mk-kit-ui-block-editor.mjs +2158 -0
package/fesm2022/mk-kit-ui-block-editor.mjs.map +1 -0
package/fesm2022/mk-kit-ui-button.mjs +81 -0
package/fesm2022/mk-kit-ui-button.mjs.map +1 -0
package/fesm2022/mk-kit-ui-checkbox.mjs +136 -0
package/fesm2022/mk-kit-ui-checkbox.mjs.map +1 -0
package/fesm2022/mk-kit-ui-chip.mjs +122 -0
package/fesm2022/mk-kit-ui-chip.mjs.map +1 -0
package/fesm2022/mk-kit-ui-context-menu.mjs +144 -0
package/fesm2022/mk-kit-ui-context-menu.mjs.map +1 -0
package/fesm2022/mk-kit-ui-core.mjs +1576 -0
package/fesm2022/mk-kit-ui-core.mjs.map +1 -0
package/fesm2022/mk-kit-ui-data.mjs +6055 -0
package/fesm2022/mk-kit-ui-data.mjs.map +1 -0
package/fesm2022/mk-kit-ui-datetime.mjs +3409 -0
package/fesm2022/mk-kit-ui-datetime.mjs.map +1 -0
package/fesm2022/mk-kit-ui-directives.mjs +1779 -0
package/fesm2022/mk-kit-ui-directives.mjs.map +1 -0
package/fesm2022/mk-kit-ui-dnd.mjs +1073 -0
package/fesm2022/mk-kit-ui-dnd.mjs.map +1 -0
package/fesm2022/mk-kit-ui-feedback.mjs +2426 -0
package/fesm2022/mk-kit-ui-feedback.mjs.map +1 -0
package/fesm2022/mk-kit-ui-forms.mjs +9208 -0
package/fesm2022/mk-kit-ui-forms.mjs.map +1 -0
package/fesm2022/mk-kit-ui-icon.mjs +470 -0
package/fesm2022/mk-kit-ui-icon.mjs.map +1 -0
package/fesm2022/mk-kit-ui-media.mjs +896 -0
package/fesm2022/mk-kit-ui-media.mjs.map +1 -0
package/fesm2022/mk-kit-ui-navigation.mjs +2542 -0
package/fesm2022/mk-kit-ui-navigation.mjs.map +1 -0
package/fesm2022/mk-kit-ui-rich-text.mjs +565 -0
package/fesm2022/mk-kit-ui-rich-text.mjs.map +1 -0
package/fesm2022/mk-kit-ui-table.mjs +1378 -0
package/fesm2022/mk-kit-ui-table.mjs.map +1 -0
package/fesm2022/mk-kit-ui.mjs +32 -0
package/fesm2022/mk-kit-ui.mjs.map +1 -0
package/package.json +130 -0
package/schematics/collection.json +10 -0
package/schematics/ng-add/index.js +113 -0
package/schematics/ng-add/schema.json +22 -0
package/schematics/package.json +3 -0
package/styles/mk-kit.css +750 -0
package/types/mk-kit-ui-block-editor.d.ts +292 -0
package/types/mk-kit-ui-button.d.ts +40 -0
package/types/mk-kit-ui-checkbox.d.ts +62 -0
package/types/mk-kit-ui-chip.d.ts +59 -0
package/types/mk-kit-ui-context-menu.d.ts +57 -0
package/types/mk-kit-ui-core.d.ts +1105 -0
package/types/mk-kit-ui-data.d.ts +2580 -0
package/types/mk-kit-ui-datetime.d.ts +1171 -0
package/types/mk-kit-ui-directives.d.ts +807 -0
package/types/mk-kit-ui-dnd.d.ts +423 -0
package/types/mk-kit-ui-feedback.d.ts +1270 -0
package/types/mk-kit-ui-forms.d.ts +3586 -0
package/types/mk-kit-ui-icon.d.ts +108 -0
package/types/mk-kit-ui-media.d.ts +549 -0
package/types/mk-kit-ui-navigation.d.ts +1169 -0
package/types/mk-kit-ui-rich-text.d.ts +187 -0
package/types/mk-kit-ui-table.d.ts +739 -0
package/types/mk-kit-ui.d.ts +17 -0

package/fesm2022/mk-kit-ui-core.mjs ADDED Viewed

@@ -0,0 +1,1576 @@
+import * as i0 from '@angular/core';
+import { inject, DOCUMENT, DestroyRef, PLATFORM_ID, signal, computed, effect, Injectable, InjectionToken, ApplicationRef, EnvironmentInjector, createComponent, Injector, ElementRef, input, output, Directive, untracked } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { Observable } from 'rxjs';
+/** Shared primitive types used across mk-kit components. */
+const STORAGE_KEY = 'mk-kit-theme';
+const THEME_ATTR = 'data-mk-theme';
+const DENSITY_STORAGE_KEY = 'mk-kit-density';
+const DENSITY_ATTR = 'data-mk-density';
+/**
+ * Reactive theme controller for mk-kit.
+ *
+ * - `preference()` is the user's choice: `light`, `dark`, or `system`.
+ * - `resolvedTheme()` is the concrete theme currently applied.
+ * - Writes `data-mk-theme` on `<html>` and persists the choice to
+ *   `localStorage`. When set to `system`, it live-tracks the OS setting and
+ *   removes the attribute so pure-CSS `prefers-color-scheme` takes over.
+ *
+ * Provided in root — inject it anywhere and bind to the signals.
+ */
+class MkThemeService {
+    document = inject(DOCUMENT);
+    destroyRef = inject(DestroyRef);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    _preference = signal(this.readInitial(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_preference" }] : /* istanbul ignore next */ []));
+    /** The user's theme preference. */
+    preference = this._preference.asReadonly();
+    _systemPrefersDark = signal(this.readSystemDark(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_systemPrefersDark" }] : /* istanbul ignore next */ []));
+    /** The concrete theme in effect (`light` or `dark`). */
+    resolvedTheme = computed(() => {
+        const pref = this._preference();
+        if (pref === 'system') {
+            return this._systemPrefersDark() ? 'dark' : 'light';
+        }
+        return pref;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedTheme" }] : /* istanbul ignore next */ []));
+    /** Convenience boolean for template bindings. */
+    isDark = computed(() => this.resolvedTheme() === 'dark', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isDark" }] : /* istanbul ignore next */ []));
+    _density = signal(this.readInitialDensity(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_density" }] : /* istanbul ignore next */ []));
+    /**
+     * The global density mode. `compact` tightens control heights and the core
+     * spacing steps via the `data-mk-density` attribute, `touch` enlarges them —
+     * every component follows automatically because they read the same tokens.
+     *
+     * This signal is the GLOBAL mode only. To make one screen or dialog touch-
+     * sized inside an otherwise comfortable app, put `data-mk-density="touch"`
+     * on that element instead; the tokens inherit and this service stays out of
+     * it.
+     */
+    density = this._density.asReadonly();
+    constructor() {
+        if (this.isBrowser) {
+            this.watchSystemPreference();
+        }
+        // Keep the DOM attribute + storage in sync with the signal.
+        effect(() => {
+            const pref = this._preference();
+            if (!this.isBrowser)
+                return;
+            const root = this.document.documentElement;
+            if (pref === 'system') {
+                root.removeAttribute(THEME_ATTR);
+            }
+            else {
+                root.setAttribute(THEME_ATTR, pref);
+            }
+            try {
+                localStorage.setItem(STORAGE_KEY, pref);
+            }
+            catch {
+                /* storage may be unavailable (private mode) — ignore */
+            }
+        });
+        // Keep the density attribute + storage in sync.
+        effect(() => {
+            const density = this._density();
+            if (!this.isBrowser)
+                return;
+            const root = this.document.documentElement;
+            // `comfortable` is the token default, so it is the ABSENCE of the
+            // attribute — anything else names itself. Written this way so a new mode
+            // needs no change here.
+            if (density === 'comfortable') {
+                root.removeAttribute(DENSITY_ATTR);
+            }
+            else {
+                root.setAttribute(DENSITY_ATTR, density);
+            }
+            try {
+                localStorage.setItem(DENSITY_STORAGE_KEY, density);
+            }
+            catch {
+                /* ignore */
+            }
+        });
+    }
+    /** Set the global density mode. */
+    setDensity(density) {
+        this._density.set(density);
+    }
+    /**
+     * Toggle between comfortable and compact — the two modes a density switch in
+     * a UI offers. `touch` is a deliberate choice for a specific screen, not
+     * something to land on by toggling, so from `touch` this returns to
+     * comfortable rather than cycling.
+     */
+    toggleDensity() {
+        this._density.update((d) => (d === 'comfortable' ? 'compact' : 'comfortable'));
+    }
+    readInitialDensity() {
+        if (!this.isBrowser)
+            return 'comfortable';
+        try {
+            const stored = localStorage.getItem(DENSITY_STORAGE_KEY);
+            if (stored === 'compact' || stored === 'comfortable' || stored === 'touch') {
+                return stored;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return 'comfortable';
+    }
+    /** Set the theme preference explicitly. */
+    setTheme(preference) {
+        this._preference.set(preference);
+    }
+    /** Toggle between light and dark (resolving `system` first). */
+    toggle() {
+        this._preference.set(this.resolvedTheme() === 'dark' ? 'light' : 'dark');
+    }
+    readInitial() {
+        if (!this.isBrowserEnv())
+            return 'system';
+        try {
+            const stored = localStorage.getItem(STORAGE_KEY);
+            if (stored === 'light' || stored === 'dark' || stored === 'system') {
+                return stored;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return 'system';
+    }
+    readSystemDark() {
+        if (!this.isBrowserEnv())
+            return false;
+        return this.document.defaultView?.matchMedia('(prefers-color-scheme: dark)')
+            .matches ?? false;
+    }
+    watchSystemPreference() {
+        const mql = this.document.defaultView?.matchMedia('(prefers-color-scheme: dark)');
+        if (!mql)
+            return;
+        const onChange = (e) => this._systemPrefersDark.set(e.matches);
+        mql.addEventListener('change', onChange);
+        // Detach when the injector dies (repeated bootstraps in SSR/HMR/tests).
+        this.destroyRef.onDestroy(() => mql.removeEventListener('change', onChange));
+    }
+    isBrowserEnv() {
+        return this.isBrowser && typeof this.document !== 'undefined';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkThemeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Announces messages to assistive technology via a visually-hidden
+ * `aria-live` region. Used by toasts, form validation, sort changes, etc.
+ * so state changes are perceivable without sight. WCAG 4.1.3 (Status Messages).
+ */
+class MkLiveAnnouncer {
+    document = inject(DOCUMENT);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    region;
+    clearTimer;
+    /** Announce `message`. `politeness` controls interruption behavior. */
+    announce(message, politeness = 'polite') {
+        if (!this.isBrowser)
+            return;
+        const region = this.ensureRegion();
+        region.setAttribute('aria-live', politeness);
+        // Clear then set on the next frame so identical consecutive messages
+        // are still re-announced by screen readers.
+        region.textContent = '';
+        if (this.clearTimer)
+            clearTimeout(this.clearTimer);
+        this.document.defaultView?.requestAnimationFrame(() => {
+            region.textContent = message;
+        });
+        // Tidy up after a while to keep the DOM clean.
+        this.clearTimer = setTimeout(() => {
+            if (this.region)
+                this.region.textContent = '';
+        }, 1000);
+    }
+    ensureRegion() {
+        if (this.region)
+            return this.region;
+        const el = this.document.createElement('div');
+        el.setAttribute('aria-atomic', 'true');
+        el.setAttribute('aria-live', 'polite');
+        el.className = 'mk-visually-hidden';
+        el.style.cssText =
+            'position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;';
+        this.document.body.appendChild(el);
+        this.region = el;
+        return el;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkLiveAnnouncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkLiveAnnouncer, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkLiveAnnouncer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+const FOCUSABLE_SELECTOR = [
+    'a[href]',
+    'button:not([disabled])',
+    'input:not([disabled]):not([type="hidden"])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    '[tabindex]:not([tabindex="-1"])',
+    '[contenteditable="true"]',
+].join(',');
+/** Returns the tabbable elements inside `root`, in DOM order. */
+function mkGetFocusable(root) {
+    const win = root.ownerDocument.defaultView;
+    return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter((el) => {
+        if (el === root.ownerDocument.activeElement)
+            return true;
+        if (el.offsetWidth <= 0 && el.offsetHeight <= 0)
+            return false;
+        // `visibility:hidden` elements keep their box, so the size check above
+        // passes — yet they are NOT tabbable, and counting one as a Tab-wrap
+        // boundary makes the wrap focus a dead element. `getComputedStyle`
+        // degrades safely in jsdom, where visibility resolves 'visible' by
+        // default, so test environments without layout keep working.
+        const visibility = win?.getComputedStyle(el).visibility;
+        return visibility !== 'hidden' && visibility !== 'collapse';
+    });
+}
+/**
+ * Traps keyboard focus within `root` (wrapping Tab / Shift+Tab), moves focus
+ * inside on activation, and restores focus to the previously-focused element
+ * on release. Essential for accessible modals/menus (WCAG 2.4.3, 2.1.2).
+ */
+class MkFocusTrap {
+    root;
+    previouslyFocused = null;
+    active = false;
+    keydownHandler = (e) => this.onKeydown(e);
+    constructor(root) {
+        this.root = root;
+    }
+    /** Activate the trap and move focus to the first focusable element (or root). */
+    activate(initialFocus) {
+        this.previouslyFocused = this.root.ownerDocument
+            .activeElement;
+        this.active = true;
+        this.root.addEventListener('keydown', this.keydownHandler, true);
+        const target = initialFocus ??
+            mkGetFocusable(this.root)[0] ??
+            this.root;
+        // Ensure programmatic focus works even on a non-tabbable container.
+        if (target === this.root && !this.root.hasAttribute('tabindex')) {
+            this.root.setAttribute('tabindex', '-1');
+        }
+        // Skip if the trap was released within the same tick, so the deferred
+        // focus can't steal focus back after release() restored it.
+        queueMicrotask(() => {
+            if (this.active)
+                target.focus();
+        });
+    }
+    /** Deactivate and restore focus to the trigger element. */
+    release() {
+        this.active = false;
+        this.root.removeEventListener('keydown', this.keydownHandler, true);
+        const previous = this.previouslyFocused;
+        this.previouslyFocused = null;
+        if (!previous)
+            return;
+        if (previous.isConnected) {
+            previous.focus?.();
+        }
+        else {
+            // The trigger left the DOM while the trap was active (a deleted row, a
+            // route change). Focusing a detached node is a silent no-op at best —
+            // land on the body instead so focus has a real, connected home.
+            this.root.ownerDocument.body?.focus?.();
+        }
+    }
+    onKeydown(e) {
+        if (e.key !== 'Tab')
+            return;
+        const focusable = mkGetFocusable(this.root);
+        if (focusable.length === 0) {
+            e.preventDefault();
+            this.root.focus();
+            return;
+        }
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        const active = this.root.ownerDocument.activeElement;
+        if (e.shiftKey && active === first) {
+            e.preventDefault();
+            last.focus();
+        }
+        else if (!e.shiftKey && active === last) {
+            e.preventDefault();
+            first.focus();
+        }
+    }
+}
+let counter = 0;
+/**
+ * Generates a stable, unique DOM id for wiring `aria-*` relationships
+ * (labels, descriptions, controls). Prefer this over `Math.random()` so
+ * ids are deterministic within a render and SSR-safe.
+ *
+ * @param prefix short semantic prefix, e.g. `mk-input`.
+ */
+function mkUniqueId(prefix = 'mk') {
+    return `${prefix}-${++counter}`;
+}
+/** Injection token exposing the data passed to an overlay component. */
+const MK_OVERLAY_DATA = new InjectionToken('MK_OVERLAY_DATA');
+/**
+ * Handle to an open overlay. Injected into the rendered component and returned
+ * from `MkOverlayService.open`. Resolve the overlay by calling `close`.
+ *
+ * The close result is exposed three ways so the handle fits whatever style the
+ * calling code already uses — they all settle together:
+ *
+ * - `result` — a signal, for template binding and signal-based components.
+ * - `closed$` — an Observable that emits once and completes, for RxJS
+ *   pipelines. A service that hands a dialog result back to its callers can
+ *   return this directly instead of wrapping the promise in `from(...)`.
+ * - `afterClosed` — a Promise, for `await` / `.then()`.
+ */
+class MkOverlayRef {
+    /** The rendered component instance (set by the service after creation). */
+    componentRef;
+    _closed = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_closed" }] : /* istanbul ignore next */ []));
+    /** Becomes `true` once the overlay has been dismissed. */
+    closed = this._closed.asReadonly();
+    _result = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_result" }] : /* istanbul ignore next */ []));
+    /**
+     * The value passed to `close`, or `undefined` while open and for a dismissal
+     * (Escape / backdrop). Read `closed()` to tell "closed with no result" apart
+     * from "still open".
+     */
+    result = this._result.asReadonly();
+    resolveClosed;
+    /** Resolves with the close result when the overlay is dismissed. */
+    afterClosed = new Promise((resolve) => {
+        this.resolveClosed = resolve;
+    });
+    emitClosed;
+    /**
+     * Emits the close result once, then completes. Subscribing after the overlay
+     * has already closed replays the result immediately, so a late subscriber
+     * never hangs.
+     */
+    closed$ = new Observable((subscriber) => {
+        if (this._closed()) {
+            subscriber.next(this._result());
+            subscriber.complete();
+            return;
+        }
+        this.emitClosed = (result) => {
+            subscriber.next(result);
+            subscriber.complete();
+        };
+        return () => {
+            this.emitClosed = undefined;
+        };
+    });
+    /** Internal disposer wired up by the service. */
+    _dispose = () => { };
+    /** Close the overlay, optionally returning a result. */
+    close(result) {
+        if (this._closed())
+            return;
+        this._closed.set(true);
+        this._result.set(result);
+        this._dispose(result);
+        this.resolveClosed(result);
+        this.emitClosed?.(result);
+    }
+}
+/**
+ * Body-level elements a modal must NOT inert:
+ * - `[popover]` — anchored panels / tooltips teleport to `document.body` and
+ *   may open ABOVE the dialog after it (a select inside a dialog); inerting
+ *   them would kill the very widget the dialog just opened.
+ * - toast / snackbar containers — transient status surfaces that must stay
+ *   reachable and announceable while a dialog is up.
+ * - `[aria-live]` — the live announcer region; an inert live region stops
+ *   announcing entirely.
+ */
+const INERT_EXEMPT_SELECTOR = '[popover], [aria-live], mk-toast-container, mk-snackbar-container';
+/**
+ * Lightweight, dependency-free overlay renderer. Instantiates a standalone
+ * component into a body-level host, manages the backdrop, focus trapping,
+ * Escape handling, and scroll locking. Powers Dialog, Menu, and others.
+ */
+class MkOverlayService {
+    appRef = inject(ApplicationRef);
+    envInjector = inject(EnvironmentInjector);
+    document = inject(DOCUMENT);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    // All coordination state lives on the INSTANCE, not the module: the service
+    // is a root singleton, so one app still shares one stack — but each test
+    // injector gets a fresh world instead of leaking overlays/locks/listeners
+    // across spec files that share a worker.
+    /** Reference count for the body scroll lock (first open locks, last close unlocks). */
+    openOverlays = 0;
+    bodyScrollLock = null;
+    /**
+     * Every overlay currently on screen, in open order (Map preserves insertion
+     * order, so the last entry is the topmost). Kept so {@link closeAll} can
+     * dismiss them and so the shared Escape listener can find the topmost
+     * dismissible overlay. Entries remove themselves on dispose.
+     */
+    openRefs = new Map();
+    /** The document currently carrying the shared Escape listener, if any. */
+    escapeListenerDoc = null;
+    /**
+     * The one document-level Escape listener, shared by every open overlay.
+     *
+     * Registered on the BUBBLE phase on purpose: widgets living inside an
+     * overlay (a menu, an anchored panel, a picker) handle Escape on their own
+     * elements during bubbling and call `preventDefault()`, so a consumed
+     * Escape arrives here already `defaultPrevented` and closes nothing. A
+     * per-overlay capture listener with `stopPropagation()` cannot do this:
+     * stopPropagation does not stop OTHER listeners on the same target, so one
+     * Escape used to close every stacked overlay at once.
+     */
+    onDocumentEscape = (event) => {
+        if (event.key !== 'Escape' || event.defaultPrevented)
+            return;
+        // Close ONLY the topmost open overlay that opted into Escape dismissal.
+        const entries = [...this.openRefs.entries()];
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const [ref, { closeOnEscape }] = entries[i];
+            if (closeOnEscape) {
+                ref.close();
+                event.preventDefault();
+                return;
+            }
+        }
+    };
+    /** (Un)register the shared Escape listener to match the open-overlay set. */
+    syncEscapeListener(doc) {
+        const needed = [...this.openRefs.values()].some((e) => e.closeOnEscape);
+        if (needed && this.escapeListenerDoc === null) {
+            doc.addEventListener('keydown', this.onDocumentEscape);
+            this.escapeListenerDoc = doc;
+        }
+        else if (!needed && this.escapeListenerDoc !== null) {
+            this.escapeListenerDoc.removeEventListener('keydown', this.onDocumentEscape);
+            this.escapeListenerDoc = null;
+        }
+    }
+    lockBodyScroll(doc) {
+        const { style } = doc.body;
+        this.bodyScrollLock = {
+            scrollY: doc.defaultView?.scrollY ?? 0,
+            prev: {
+                position: style.position,
+                top: style.top,
+                left: style.left,
+                right: style.right,
+                width: style.width,
+                overflow: style.overflow,
+            },
+        };
+        // overflow:hidden still does the whole job on desktop (and avoids a
+        // scroll jump there); the fixed-body treatment is what actually stops iOS
+        // touch scrolling. `top: -scrollY` keeps the page visually where it was.
+        style.overflow = 'hidden';
+        style.position = 'fixed';
+        style.top = `-${this.bodyScrollLock.scrollY}px`;
+        style.left = '0';
+        style.right = '0';
+        style.width = '100%';
+    }
+    unlockBodyScroll(doc) {
+        if (!this.bodyScrollLock)
+            return;
+        const { scrollY, prev } = this.bodyScrollLock;
+        this.bodyScrollLock = null;
+        const { style } = doc.body;
+        style.position = prev.position;
+        style.top = prev.top;
+        style.left = prev.left;
+        style.right = prev.right;
+        style.width = prev.width;
+        style.overflow = prev.overflow;
+        // Fixing the body collapsed the document's scroll position to 0; jump
+        // back instantly (never smooth — the restoration must be invisible).
+        // Guarded for jsdom, where scrollTo is unimplemented.
+        const view = doc.defaultView;
+        if (scrollY !== 0 && typeof view?.scrollTo === 'function') {
+            view.scrollTo({ top: scrollY, behavior: 'instant' });
+        }
+    }
+    /** How many overlays are currently open. */
+    get openCount() {
+        return this.openRefs.size;
+    }
+    /**
+     * Close every open overlay, newest first. Each is closed with no result, so
+     * `afterClosed` resolves undefined exactly as a backdrop click or Escape
+     * would. Safe to call when nothing is open.
+     */
+    closeAll() {
+        // Iterate a COPY: close() disposes synchronously, which mutates the map.
+        for (const ref of [...this.openRefs.keys()].reverse())
+            ref.close();
+    }
+    /**
+     * Injector teardown closes everything still open. In an app this runs only
+     * at shutdown; in tests it runs on every `TestBed.resetTestingModule()`,
+     * so an overlay a spec forgot to close cannot leak its scroll lock, focus
+     * trap, inert marks, or document listeners into later spec files sharing
+     * the worker.
+     */
+    ngOnDestroy() {
+        this.closeAll();
+    }
+    open(component, config = {}) {
+        const { hasBackdrop = true, closeOnBackdropClick = true, closeOnEscape = true, trapFocus = true, autoFocus = true, role = 'dialog', } = config;
+        const overlayRef = new MkOverlayRef();
+        if (!this.isBrowser) {
+            // Nothing to render on the server; return an inert ref.
+            return overlayRef;
+        }
+        const container = this.document.createElement('div');
+        container.className = 'mk-overlay-container';
+        container.style.cssText =
+            'position:fixed;inset:0;z-index:var(--mk-z-overlay,1000);display:flex;align-items:center;justify-content:center;';
+        if (!hasBackdrop) {
+            // Without a scrim the fullscreen container must not swallow clicks
+            // meant for the page; the panel re-enables pointer events for itself.
+            container.style.pointerEvents = 'none';
+        }
+        let backdrop;
+        if (hasBackdrop) {
+            backdrop = this.document.createElement('div');
+            backdrop.className = 'mk-overlay-backdrop';
+            backdrop.style.cssText =
+                'position:absolute;inset:0;background:var(--mk-overlay-scrim,rgba(0,0,0,0.45));animation:mk-overlay-fade var(--mk-duration-fast,140ms) var(--mk-ease-out,ease);';
+            container.appendChild(backdrop);
+            if (closeOnBackdropClick) {
+                backdrop.addEventListener('click', () => overlayRef.close());
+            }
+        }
+        const panel = this.document.createElement('div');
+        panel.className = 'mk-overlay-panel';
+        if (config.panelClass) {
+            const classes = Array.isArray(config.panelClass)
+                ? config.panelClass
+                : [config.panelClass];
+            panel.classList.add(...classes);
+        }
+        panel.style.cssText = 'position:relative;max-width:100%;max-height:100%;';
+        if (!hasBackdrop)
+            panel.style.pointerEvents = 'auto';
+        panel.setAttribute('role', role);
+        panel.setAttribute('aria-modal', role === 'menu' ? 'false' : 'true');
+        if (config.ariaLabel)
+            panel.setAttribute('aria-label', config.ariaLabel);
+        container.appendChild(panel);
+        // Create the component with an injector exposing the data + ref.
+        const componentRef = createComponent(component, {
+            environmentInjector: this.envInjector,
+            hostElement: panel,
+            elementInjector: Injector.create({
+                parent: config.injector ?? this.envInjector,
+                providers: [
+                    { provide: MK_OVERLAY_DATA, useValue: config.data ?? null },
+                    { provide: MkOverlayRef, useValue: overlayRef },
+                ],
+            }),
+        });
+        overlayRef.componentRef = componentRef;
+        this.appRef.attachView(componentRef.hostView);
+        this.document.body.appendChild(container);
+        // Lock body scroll while any overlay is open (see lockBodyScroll for the
+        // iOS-proof fixed-body technique and the reference counting).
+        if (this.openOverlays++ === 0) {
+            this.lockBodyScroll(this.document);
+        }
+        // Make the rest of the page inert while a MODAL overlay is open —
+        // `aria-modal="true"` alone does not stop Tab or a screen reader's
+        // reading cursor from reaching background content (WCAG 2.4.3 / 1.3.2).
+        // A backdropless overlay is deliberately non-blocking, so it inerts
+        // nothing. Only the elements THIS overlay inerted are recorded, so
+        // nested modals unwind correctly: the inner dialog skips (and therefore
+        // never un-inerts) whatever the outer dialog already inerted.
+        const isModal = hasBackdrop && role !== 'menu';
+        const inerted = [];
+        if (isModal) {
+            for (const sibling of Array.from(this.document.body.children)) {
+                if (sibling === container ||
+                    sibling.hasAttribute('inert') ||
+                    sibling.matches(INERT_EXEMPT_SELECTOR)) {
+                    continue;
+                }
+                sibling.setAttribute('inert', '');
+                inerted.push(sibling);
+            }
+        }
+        // Focus management.
+        const focusTrap = trapFocus ? new MkFocusTrap(panel) : undefined;
+        // `autoFocus: false` focuses the panel rather than its first control, so
+        // the trap still contains Tab and restores focus on close.
+        focusTrap?.activate(autoFocus ? undefined : panel);
+        // Escape handling goes through ONE shared document listener (see
+        // `onDocumentEscape`) so stacked overlays close one per keypress,
+        // topmost first, and inner widgets can consume Escape before us.
+        this.openRefs.set(overlayRef, { closeOnEscape });
+        this.syncEscapeListener(this.document);
+        overlayRef._dispose = () => {
+            this.openRefs.delete(overlayRef);
+            this.syncEscapeListener(this.document);
+            for (const el of inerted)
+                el.removeAttribute('inert');
+            focusTrap?.release();
+            // ApplicationRef destroys its views before root-injector destroy hooks
+            // run — detaching then would throw (same guard as MkTourService).
+            if (!this.appRef.destroyed)
+                this.appRef.detachView(componentRef.hostView);
+            componentRef.destroy();
+            container.remove();
+            if (--this.openOverlays === 0) {
+                this.unlockBodyScroll(this.document);
+            }
+        };
+        return overlayRef;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkOverlayService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkOverlayService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Never shrink a panel below this via the viewport size cap — a sub-120px
+ * dropdown is unusable; at that point overflowing beats collapsing.
+ */
+const MIN_SIZE_CAP = 120;
+function sideOf(placement) {
+    if (placement.startsWith('top'))
+        return 'top';
+    if (placement.startsWith('bottom'))
+        return 'bottom';
+    return placement;
+}
+function alignOf(placement) {
+    if (placement.endsWith('-start'))
+        return 'start';
+    if (placement.endsWith('-end'))
+        return 'end';
+    return 'center';
+}
+/**
+ * Pure viewport-positioning maths shared by every anchored overlay
+ * ({@link MkAnchoredPanel} and the tooltip). Given the anchor rect, the panel
+ * size and the viewport size, returns the top/left for a `position: fixed`
+ * panel — flipping to the opposite side when it would overflow and clamping
+ * back inside the viewport.
+ */
+function mkComputeAnchoredPosition(anchor, panel, viewport, opts) {
+    const { gap, flip, clamp } = opts;
+    let side = sideOf(opts.placement);
+    const align = alignOf(opts.placement);
+    const { width: w, height: h } = panel;
+    const { width: vw, height: vh } = viewport;
+    // Vertical flip for top/bottom placements.
+    if (flip && (side === 'top' || side === 'bottom')) {
+        const fitsBelow = anchor.bottom + gap + h <= vh;
+        const fitsAbove = anchor.top - gap - h >= 0;
+        if (side === 'bottom' && !fitsBelow && fitsAbove)
+            side = 'top';
+        else if (side === 'top' && !fitsAbove && fitsBelow)
+            side = 'bottom';
+    }
+    // Horizontal flip for left/right placements.
+    if (flip && (side === 'left' || side === 'right')) {
+        const fitsRight = anchor.right + gap + w <= vw;
+        const fitsLeft = anchor.left - gap - w >= 0;
+        if (side === 'right' && !fitsRight && fitsLeft)
+            side = 'left';
+        else if (side === 'left' && !fitsLeft && fitsRight)
+            side = 'right';
+    }
+    let top = 0;
+    let left = 0;
+    if (side === 'bottom')
+        top = anchor.bottom + gap;
+    else if (side === 'top')
+        top = anchor.top - h - gap;
+    else if (side === 'right')
+        left = anchor.right + gap;
+    else
+        left = anchor.left - w - gap;
+    if (side === 'top' || side === 'bottom') {
+        // Cross axis is horizontal; in RTL, inline-start is the anchor's right edge.
+        const startLeft = opts.rtl ? anchor.right - w : anchor.left;
+        const endLeft = opts.rtl ? anchor.left : anchor.right - w;
+        if (align === 'start')
+            left = startLeft;
+        else if (align === 'end')
+            left = endLeft;
+        else
+            left = anchor.left + anchor.width / 2 - w / 2;
+    }
+    else {
+        // Left/right: centre on the cross (vertical) axis.
+        top = anchor.top + anchor.height / 2 - h / 2;
+    }
+    if (clamp) {
+        left = Math.max(gap, Math.min(left, vw - w - gap));
+        top = Math.max(gap, Math.min(top, vh - h - gap));
+    }
+    return { top: Math.round(top), left: Math.round(left), placement: `${side}${align === 'center' ? '' : `-${align}`}` };
+}
+/**
+ * Anchored-overlay directive. Apply it to a floating panel element (a dropdown
+ * list, calendar, menu, …) that is rendered inside its component's own template
+ * — typically inside an `@if (open()) { … }` block. On init the directive
+ * **teleports the panel to `document.body` and into the browser top layer** via
+ * the native Popover API (`popover="manual"` + `showPopover()`), then positions
+ * it against the anchor with `position: fixed`. Because the element stays part
+ * of the component's Angular view, all bindings, `@for` content, events and
+ * projected content keep working after the move.
+ *
+ * The top layer is immune to ancestor `overflow`, `transform` and `z-index`
+ * stacking contexts, so the panel can never be clipped by a container or hidden
+ * behind sibling content. Where the Popover API is unavailable the panel still
+ * renders in a `document.body` portal with a `z-index` fallback.
+ *
+ * ```html
+ * <ul #panel mkAnchoredPanel [mkAnchoredPanelFor]="trigger" [matchWidth]="true"
+ *     (dismiss)="close()"> … </ul>
+ * ```
+ */
+class MkAnchoredPanel {
+    host = inject(ElementRef);
+    document = inject(DOCUMENT);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    /** The trigger element to position against. */
+    anchor = input(undefined, { ...(ngDevMode ? { debugName: "anchor" } : /* istanbul ignore next */ {}), alias: 'mkAnchoredPanelFor' });
+    /** Viewport-point anchor (e.g. a right-click position) — takes precedence. */
+    anchorRect = input(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "anchorRect" }] : /* istanbul ignore next */ []));
+    /** Preferred placement relative to the anchor. */
+    placement = input('bottom-start', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "placement" }] : /* istanbul ignore next */ []));
+    /** Distance in px between the anchor and the panel. */
+    gap = input(4, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "gap" }] : /* istanbul ignore next */ []));
+    /** Set the panel's `min-width` to the anchor's width (dropdowns). */
+    matchWidth = input(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "matchWidth" }] : /* istanbul ignore next */ []));
+    /** Flip to the opposite side when the preferred side would overflow. */
+    flip = input(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "flip" }] : /* istanbul ignore next */ []));
+    /** Clamp the panel inside the viewport. */
+    clamp = input(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "clamp" }] : /* istanbul ignore next */ []));
+    /** Emitted on an outside pointerdown or when the window loses focus. */
+    dismiss = output();
+    popover = false;
+    /** Whether {@link position} applied an inline viewport size cap (`max-*`). */
+    sizeCapped = false;
+    repositionRaf = null;
+    /**
+     * Scroll-driven repositions track the anchor without clamping, so the
+     * panel follows its trigger instead of detaching and hugging the viewport
+     * edge; open/resize positioning clamps as usual.
+     */
+    pendingTrack = true;
+    /** rAF-coalesced repositioning — at most one layout pass per frame. */
+    reposition(track) {
+        // A clamped (open/resize) request in the same frame wins over tracking.
+        this.pendingTrack &&= track;
+        if (this.repositionRaf != null)
+            return;
+        this.repositionRaf =
+            this.document.defaultView?.requestAnimationFrame(() => {
+                this.repositionRaf = null;
+                const wasTrack = this.pendingTrack;
+                this.pendingTrack = true;
+                this.position(wasTrack);
+            }) ?? null;
+    }
+    onScroll = () => this.reposition(true);
+    onResize = () => this.reposition(false);
+    onDocPointerdown = (e) => {
+        const target = e.target;
+        if (this.host.nativeElement.contains(target))
+            return;
+        const anchorEl = this.resolveAnchorEl();
+        if (anchorEl?.contains(target))
+            return;
+        this.dismiss.emit();
+    };
+    onWindowBlur = () => this.dismiss.emit();
+    ngAfterViewInit() {
+        if (!this.isBrowser)
+            return;
+        const el = this.host.nativeElement;
+        el.style.position = 'fixed';
+        el.style.margin = '0';
+        el.style.inset = 'auto';
+        // setProperty (not .style.zIndex) so the CSS var() value is accepted. Only
+        // matters in the no-Popover fallback; the top layer ignores z-index.
+        el.style.setProperty('z-index', 'var(--mk-z-menu)');
+        this.document.body.appendChild(el);
+        // Promote into the top layer when the Popover API is available.
+        const withPopover = el;
+        if (typeof withPopover.showPopover === 'function') {
+            el.setAttribute('popover', 'manual');
+            try {
+                withPopover.showPopover();
+                this.popover = true;
+            }
+            catch {
+                // Already open or unsupported context — fall back to the body portal.
+                // The attribute must go too: with it left on, the UA sheet's
+                // `[popover]:not(:popover-open) { display: none }` hides the panel.
+                el.removeAttribute('popover');
+                this.popover = false;
+            }
+        }
+        this.position();
+        const view = this.document.defaultView;
+        view?.addEventListener('scroll', this.onScroll, {
+            capture: true,
+            passive: true,
+        });
+        view?.addEventListener('resize', this.onResize);
+        view?.addEventListener('blur', this.onWindowBlur);
+        // iOS's software keyboard (and pinch-zoom) resizes/pans only the VISUAL
+        // viewport — `window` never fires resize/scroll for it — so listen there
+        // too, into the same reposition paths. Feature-detected: jsdom and older
+        // browsers have no visualViewport.
+        const visual = view?.visualViewport;
+        visual?.addEventListener('resize', this.onResize);
+        visual?.addEventListener('scroll', this.onScroll);
+        this.document.addEventListener('pointerdown', this.onDocPointerdown, true);
+        // Re-measure once layout has settled (fonts, async content).
+        view?.requestAnimationFrame(() => this.position());
+    }
+    /**
+     * Recompute and apply the panel position. Safe to call at any time.
+     * With `track` (scroll-driven), the panel follows the anchor unclamped and
+     * dismisses once the anchor leaves the viewport (matching the CDK's
+     * reposition-with-auto-close scroll behaviour).
+     */
+    position(track = false) {
+        if (!this.isBrowser)
+            return;
+        const el = this.host.nativeElement;
+        const view = this.document.defaultView;
+        if (!view)
+            return;
+        const anchor = this.resolveAnchorRect();
+        if (!anchor)
+            return;
+        // Prefer the visual viewport when it exists and is measured: on iOS the
+        // software keyboard shrinks only `visualViewport`, never the layout
+        // viewport, so clamp/flip maths against `documentElement.client*` would
+        // keep placing panels underneath the keyboard. Fallback (no visualViewport,
+        // or one reporting 0×0 pre-measure) keeps the existing behaviour, including
+        // the jsdom "unmeasured viewport" guards below.
+        const visual = view.visualViewport;
+        const useVisual = visual != null && visual.width > 0 && visual.height > 0;
+        const vw = useVisual ? visual.width : this.document.documentElement.clientWidth;
+        const vh = useVisual ? visual.height : this.document.documentElement.clientHeight;
+        // Anchor scrolled fully out of view — the panel would float detached.
+        // Zero-size anchor rects and a zero-size viewport are skipped: they mean
+        // "not yet measured" (jsdom, SSR hydration), not "off-screen".
+        if (track &&
+            !this.anchorRect() &&
+            vw > 0 &&
+            vh > 0 &&
+            (anchor.width > 0 || anchor.height > 0) &&
+            (anchor.bottom <= 0 || anchor.top >= vh || anchor.right <= 0 || anchor.left >= vw)) {
+            this.dismiss.emit();
+            return;
+        }
+        if (this.matchWidth() && anchor.width > 0) {
+            el.style.minWidth = `${Math.round(anchor.width)}px`;
+        }
+        const gap = this.gap();
+        // Viewport size cap: a panel wider or taller than the screen (a fat menu
+        // on a 360px phone) gets an inline `max-width`/`max-height` so it scrolls
+        // internally instead of overflowing. An inline max-* OVERRIDES any
+        // stylesheet max (e.g. a select list's own 16rem max-height), so the cap
+        // is applied only when the panel's NATURAL size exceeds it — it never
+        // enlarges a panel that already limits itself. A previously applied cap is
+        // cleared first so the natural size is re-measured against the current
+        // viewport. Scroll-tracking frames skip all of this: the viewport has not
+        // resized mid-scroll, and clearing/re-measuring would force two extra
+        // reflows per frame.
+        if (!track && this.sizeCapped) {
+            el.style.removeProperty('max-width');
+            el.style.removeProperty('max-height');
+            this.sizeCapped = false;
+        }
+        let rect = el.getBoundingClientRect();
+        if (!track && vw > 0 && vh > 0) {
+            const capW = Math.max(MIN_SIZE_CAP, Math.floor(vw - 2 * gap));
+            const capH = Math.max(MIN_SIZE_CAP, Math.floor(vh - 2 * gap));
+            const capWidth = rect.width > capW;
+            const capHeight = rect.height > capH;
+            if (capWidth)
+                el.style.maxWidth = `${capW}px`;
+            if (capHeight)
+                el.style.maxHeight = `${capH}px`;
+            if (capWidth || capHeight) {
+                this.sizeCapped = true;
+                rect = el.getBoundingClientRect();
+            }
+        }
+        const pos = mkComputeAnchoredPosition(anchor, { width: rect.width, height: rect.height }, { width: vw, height: vh }, {
+            placement: this.placement(),
+            gap,
+            flip: this.flip(),
+            clamp: this.clamp() && !track,
+            rtl: this.isAnchorRtl(),
+        });
+        el.style.top = `${pos.top}px`;
+        el.style.left = `${pos.left}px`;
+        el.setAttribute('data-placement', pos.placement);
+    }
+    /** Whether the anchor renders in a right-to-left context. */
+    isAnchorRtl() {
+        const el = this.resolveAnchorEl();
+        const view = this.document.defaultView;
+        if (!el || !view)
+            return false;
+        return view.getComputedStyle(el).direction === 'rtl';
+    }
+    resolveAnchorEl() {
+        const a = this.anchor();
+        if (!a)
+            return null;
+        return a instanceof ElementRef ? a.nativeElement : a;
+    }
+    resolveAnchorRect() {
+        const point = this.anchorRect();
+        if (point) {
+            return {
+                top: point.y,
+                left: point.x,
+                right: point.x,
+                bottom: point.y,
+                width: 0,
+                height: 0,
+            };
+        }
+        return this.resolveAnchorEl()?.getBoundingClientRect() ?? null;
+    }
+    ngOnDestroy() {
+        if (!this.isBrowser)
+            return;
+        const el = this.host.nativeElement;
+        const view = this.document.defaultView;
+        if (this.repositionRaf != null) {
+            view?.cancelAnimationFrame(this.repositionRaf);
+            this.repositionRaf = null;
+        }
+        view?.removeEventListener('scroll', this.onScroll, true);
+        view?.removeEventListener('resize', this.onResize);
+        view?.removeEventListener('blur', this.onWindowBlur);
+        const visual = view?.visualViewport;
+        visual?.removeEventListener('resize', this.onResize);
+        visual?.removeEventListener('scroll', this.onScroll);
+        this.document.removeEventListener('pointerdown', this.onDocPointerdown, true);
+        const withPopover = el;
+        if (this.popover && typeof withPopover.hidePopover === 'function') {
+            try {
+                withPopover.hidePopover();
+            }
+            catch {
+                // Ignore — the element may already be disconnected.
+            }
+            el.removeAttribute('popover');
+        }
+        // Remove the teleported node ourselves. It was moved out of the component's
+        // view into `document.body`, so Angular's view teardown removes it by
+        // reference (`node.remove()`); re-inserting it anywhere would orphan a
+        // detached copy, leaking one panel per open/close cycle. A plain remove is
+        // idempotent whichever teardown step runs first.
+        el.remove();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkAnchoredPanel, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.7", type: MkAnchoredPanel, isStandalone: true, selector: "[mkAnchoredPanel]", inputs: { anchor: { classPropertyName: "anchor", publicName: "mkAnchoredPanelFor", isSignal: true, isRequired: false, transformFunction: null }, anchorRect: { classPropertyName: "anchorRect", publicName: "anchorRect", isSignal: true, isRequired: false, transformFunction: null }, placement: { classPropertyName: "placement", publicName: "placement", isSignal: true, isRequired: false, transformFunction: null }, gap: { classPropertyName: "gap", publicName: "gap", isSignal: true, isRequired: false, transformFunction: null }, matchWidth: { classPropertyName: "matchWidth", publicName: "matchWidth", isSignal: true, isRequired: false, transformFunction: null }, flip: { classPropertyName: "flip", publicName: "flip", isSignal: true, isRequired: false, transformFunction: null }, clamp: { classPropertyName: "clamp", publicName: "clamp", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { dismiss: "dismiss" }, exportAs: ["mkAnchoredPanel"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: MkAnchoredPanel, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mkAnchoredPanel]',
+                    exportAs: 'mkAnchoredPanel',
+                }]
+        }], propDecorators: { anchor: [{ type: i0.Input, args: [{ isSignal: true, alias: "mkAnchoredPanelFor", required: false }] }], anchorRect: [{ type: i0.Input, args: [{ isSignal: true, alias: "anchorRect", required: false }] }], placement: [{ type: i0.Input, args: [{ isSignal: true, alias: "placement", required: false }] }], gap: [{ type: i0.Input, args: [{ isSignal: true, alias: "gap", required: false }] }], matchWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "matchWidth", required: false }] }], flip: [{ type: i0.Input, args: [{ isSignal: true, alias: "flip", required: false }] }], clamp: [{ type: i0.Input, args: [{ isSignal: true, alias: "clamp", required: false }] }], dismiss: [{ type: i0.Output, args: ["dismiss"] }] } });
+/** The built-in English validation messages. */
+const MK_DEFAULT_VALIDATION = {
+    required: 'This field is required',
+    email: 'Enter a valid email address',
+    min: ({ min }) => `Must be ${min} or more`,
+    max: ({ max }) => `Must be ${max} or less`,
+    minlength: ({ requiredLength }) => `Must be at least ${requiredLength} characters`,
+    maxlength: ({ requiredLength }) => `Must be at most ${requiredLength} characters`,
+    pattern: 'Enter a value in the expected format',
+    mkMinDate: ({ min }) => `Must be on or after ${min.toLocaleDateString()}`,
+    mkMaxDate: ({ max }) => `Must be on or before ${max.toLocaleDateString()}`,
+    mkDateFilter: 'This date is not available',
+    mkDateRangeIncomplete: 'Select both a start and an end date',
+    mkMinTime: ({ min }) => `Must be at or after ${min}`,
+    mkMaxTime: ({ max }) => `Must be at or before ${max}`,
+    mkMaxItems: ({ max }) => `Select at most ${max} ${max === 1 ? 'item' : 'items'}`,
+    mkFileSize: ({ name, maxLabel }) => `${name} is larger than ${maxLabel}`,
+    mkFileType: ({ name }) => `${name} is not an accepted file type`,
+    cardNumber: 'Enter a valid card number',
+    iban: ({ expectedLength }) => expectedLength
+        ? `Enter a valid IBAN (${expectedLength} characters)`
+        : 'Enter a valid IBAN',
+    postalCode: ({ example }) => `Enter a valid postal code, e.g. ${example}`,
+    taxId: ({ label, example }) => `Enter a valid ${label}, e.g. ${example}`,
+    unknown: 'This value is not valid',
+};
+/** The built-in English date names. */
+const MK_DEFAULT_DATE_NAMES = {
+    months: [
+        'January', 'February', 'March', 'April', 'May', 'June',
+        'July', 'August', 'September', 'October', 'November', 'December',
+    ],
+    monthsShort: [
+        'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+        'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',
+    ],
+    weekdays: [
+        'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
+    ],
+    weekdaysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    weekdaysNarrow: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+};
+const PASSWORD_STRENGTH_LABELS = ['Weak', 'Weak', 'Fair', 'Good', 'Strong'];
+/** The built-in English strings. */
+const MK_DEFAULT_I18N = {
+    validation: MK_DEFAULT_VALIDATION,
+    close: 'Close',
+    dismiss: 'Dismiss',
+    clear: 'Clear',
+    confirm: 'Confirm',
+    cancel: 'Cancel',
+    ok: 'OK',
+    save: 'Save',
+    submit: 'Submit',
+    edit: 'Edit',
+    remove: 'Remove',
+    removeItem: (name) => `Remove ${name}`,
+    empty: 'Empty',
+    optional: 'Optional',
+    filter: 'Filter…',
+    confirmMessage: 'Are you sure?',
+    decrease: 'Decrease',
+    increase: 'Increase',
+    loading: 'Loading…',
+    noOptions: 'No options',
+    noResults: 'No results',
+    noData: 'No data to display',
+    resultsCount: (count) => (count === 1 ? '1 result' : `${count} results`),
+    previousPage: 'Go to previous page',
+    nextPage: 'Go to next page',
+    goToPage: (page) => `Go to page ${page}`,
+    paginationLabel: 'Pagination',
+    previousSlide: 'Previous slide',
+    nextSlide: 'Next slide',
+    goToSlide: (slide) => `Go to slide ${slide}`,
+    carouselLabel: 'Carousel',
+    pauseSlideshow: 'Pause slideshow',
+    playSlideshow: 'Play slideshow',
+    slideOf: (slide, total) => `Slide ${slide} of ${total}`,
+    dateNames: MK_DEFAULT_DATE_NAMES,
+    previousMonth: 'Previous month',
+    nextMonth: 'Next month',
+    previousYear: 'Previous year',
+    nextYear: 'Next year',
+    previousYears: 'Previous years',
+    nextYears: 'Next years',
+    selectDate: 'Select date…',
+    selectRange: 'Select range…',
+    selectTime: 'Select time…',
+    selectMonth: 'Select month…',
+    selectYear: 'Select year…',
+    selectWeek: 'Select week…',
+    selectPlaceholder: 'Select…',
+    chooseDate: 'Choose date',
+    chooseDateRange: 'Choose date range',
+    chooseMonth: 'Choose month',
+    chooseYear: 'Choose year',
+    chooseWeek: 'Choose week',
+    openCalendar: 'Open calendar',
+    openTimeList: 'Open time list',
+    daySegment: 'Day',
+    monthSegment: 'Month',
+    yearSegment: 'Year',
+    countdownDays: 'days',
+    countdownHours: 'hrs',
+    countdownMinutes: 'min',
+    countdownSeconds: 'sec',
+    countdownFinished: 'Finished',
+    dayEvents: (count, titles) => `${count} ${count === 1 ? 'event' : 'events'}${titles ? `: ${titles}` : ''}`,
+    moreEvents: (count) => `+${count} more`,
+    selectAllRows: 'Select all rows',
+    selectRow: (row) => (row ? `Select row ${row}` : 'Select row'),
+    expandHeader: 'Expand',
+    expandRow: 'Expand row',
+    collapseRow: 'Collapse row',
+    expandGroup: 'Expand group',
+    collapseGroup: 'Collapse group',
+    groupCount: (count) => `${count} item${count === 1 ? '' : 's'}`,
+    resizeColumn: 'Resize column',
+    columnWidth: (column, width) => `${column} column width ${width} pixels`,
+    columnMoved: (column, position, total) => `${column} moved to position ${position} of ${total}`,
+    editCell: 'Press Enter to edit',
+    cellSaved: (value) => `Saved ${value}`,
+    sortedBy: (column, direction) => `Sorted by ${column} ${direction === 'asc' ? 'ascending' : 'descending'}`,
+    sortingCleared: (column) => `Sorting cleared on ${column}`,
+    showPassword: 'Show password',
+    hidePassword: 'Hide password',
+    passwordRuleMinLength: (length) => `At least ${length} characters`,
+    passwordRuleUppercase: 'An uppercase letter',
+    passwordRuleNumber: 'A number',
+    passwordRuleSymbol: 'A symbol',
+    passwordStrength: (score) => PASSWORD_STRENGTH_LABELS[Math.max(0, Math.min(4, score))],
+    passwordStrengthLabel: 'Password strength:',
+    ruleMet: 'Met:',
+    ruleNotMet: 'Not met:',
+    oneTimeCode: 'One-time code',
+    otpDigit: (position) => `Digit ${position}`,
+    numericKeypadLabel: 'Numeric keypad',
+    keypadClear: 'Clear',
+    keypadBackspace: 'Backspace',
+    keypadDigitsEntered: (count, length) => `${count} of ${length} digits entered`,
+    onScreenKeyboardLabel: 'On-screen keyboard',
+    keyboardShift: 'Shift',
+    keyboardSpace: 'Space',
+    keyboardEnter: 'Enter',
+    keyboardAltLayer: 'More characters',
+    keyboardBaseLayer: 'Letters',
+    ratingLabel: 'Rating',
+    ratingValueText: (value, max) => `${value} of ${max} stars`,
+    minimum: 'Minimum',
+    maximum: 'Maximum',
+    chooseColor: 'Choose color',
+    hexValue: 'Hex value',
+    presetColors: 'Preset colors',
+    chooseCountry: 'Choose country',
+    searchCountries: 'Search countries…',
+    phoneNumber: 'Phone number',
+    postalCode: 'Postal code',
+    amount: 'Amount',
+    cardNumber: 'Card number',
+    cardBrand: (brand) => `Card brand: ${brand}`,
+    iban: 'IBAN',
+    taxId: 'Tax ID',
+    signature: 'Signature',
+    jsonLabel: 'JSON',
+    logViewerLabel: 'Log output',
+    logFollow: 'Follow',
+    logCopyAll: 'Copy log',
+    logWrapLines: 'Wrap lines',
+    eventCalendarGrabbed: (title, from, to) => `${title} grabbed, ${from} – ${to}. Use the arrow keys to move, ` +
+        'Shift with Up or Down to change the end time, Enter to save, ' +
+        'Escape to cancel.',
+    eventCalendarPosition: (title, day, from, to) => `${title}, ${day}, ${from} – ${to}.`,
+    eventCalendarMoved: (title, day, from, to) => `${title} moved to ${day}, ${from} – ${to}.`,
+    eventCalendarResized: (title, to) => `${title} now ends at ${to}.`,
+    eventCalendarEditCancelled: 'Move cancelled. The event keeps its original time.',
+    eventCalendarMovableEvent: 'Movable event',
+    previousImage: 'Previous image',
+    nextImage: 'Next image',
+    imageOf: (index, total) => `Image ${index} of ${total}`,
+    viewImage: (alt) => (alt ? `View ${alt}` : 'View image'),
+    imageFailed: 'Image failed to load',
+    zoom: 'Zoom',
+    zoomIn: 'Zoom in',
+    zoomOut: 'Zoom out',
+    mediaLibrary: 'Media library',
+    dropzoneLabel: 'Drag files here or click to browse',
+    uploadFailed: 'Upload failed',
+    retryUpload: 'Retry upload',
+    errorSummaryTitle: 'There is a problem',
+    available: 'Available',
+    selected: 'Selected',
+    transferSelected: (target) => `Move selected to ${target}`,
+    transferAll: (target) => `Move all to ${target}`,
+    itemsMoved: (count, target) => `Moved ${count} ${count === 1 ? 'item' : 'items'} to ${target}`,
+    notificationsTitle: 'Notifications',
+    allCaughtUp: "You're all caught up",
+    markAllRead: 'Mark all read',
+    notificationsUnread: (count) => `Notifications, ${count} unread`,
+    unread: 'Unread',
+    tourStepOf: (step, total) => `Step ${step} of ${total}`,
+    tourSkip: 'Skip',
+    tourPrevious: 'Previous',
+    tourNext: 'Next',
+    tourDone: 'Done',
+    commandPalettePlaceholder: 'Type a command or search…',
+    commandPaletteLabel: 'Command palette',
+    stepCompleted: 'Completed',
+    stepError: 'Has errors',
+    diffAddedLine: 'Added:',
+    diffRemovedLine: 'Removed:',
+    itemAdded: (name) => `${name} added`,
+    itemRemoved: (name) => `${name} removed`,
+    resizePanes: 'Resize panes',
+    backToTop: 'Back to top',
+    breadcrumbLabel: 'Breadcrumb',
+    fabLabel: 'Actions',
+    diffBefore: 'Before',
+    diffAfter: 'After',
+    diffChanges: 'Changes',
+    skipToContent: 'Skip to content',
+    primaryNav: 'Primary',
+    dndPickedUp: (position, total) => `Picked up. Item ${position} of ${total}. ` +
+        'Use the arrow keys to move, space or enter to drop, escape to cancel.',
+    dndMoved: (position, total) => `Moved to position ${position} of ${total}.`,
+    dndMovedToList: (list, position, total) => `Moved to ${list}, position ${position} of ${total}.`,
+    dndDropped: (position) => `Dropped at position ${position}.`,
+    dndCancelled: 'Movement cancelled. Item returned to its starting position.',
+    repeaterAddRow: 'Add row',
+    repeaterRemoveRow: (index) => `Remove row ${index}`,
+    repeaterReorderRow: (index) => `Reorder row ${index}`,
+    repeaterRowMoved: (from, to) => `Row moved from position ${from} to position ${to}.`,
+    fileRejectedType: (name) => `${name}: unsupported type`,
+    fileRejectedSize: (name, limit) => `${name}: exceeds ${limit}`,
+    fileRejectedCount: (name, max) => `${name}: over the ${max}-file limit`,
+    chartCategory: 'Category',
+    chartValue: 'Value',
+    chartSeries: 'Series',
+    chartSlice: 'Slice',
+    chartStage: 'Stage',
+    chartConversion: 'Conversion',
+    chartAxis: 'Axis',
+    chartShare: 'Share',
+    chartLabel: 'Label',
+    qrCodeLabel: (text) => `QR code: ${text}`,
+    blockEditor: {
+        addBlock: 'Add block',
+        addFirstBlock: 'Add your first block',
+        insertBlockHere: 'Insert a block here',
+        blockInserter: 'Block inserter',
+        searchBlocks: 'Search blocks…',
+        blocks: 'Blocks',
+        moveBlockUp: 'Move block up',
+        moveBlockDown: 'Move block down',
+        blockOptions: 'Block options',
+        duplicate: 'Duplicate',
+        remove: 'Remove',
+        textFormatting: 'Text formatting',
+        altText: 'Alt text',
+        caption: 'Caption',
+        alignment: 'Alignment',
+        replaceImage: 'Replace image',
+        imageUrl: 'Image URL',
+        externalContent: 'External content',
+        embedUrl: 'Embed URL',
+        columnSettings: 'Column settings',
+        columns: 'Columns',
+        ratio: 'Ratio',
+        gap: 'Gap',
+        align: 'Align',
+        justify: 'Justify',
+        headingLevel: (level) => `Heading level ${level}`,
+        editorLabel: 'Block content editor',
+        emptyBlockPlaceholder: 'Type / to choose a block, or start writing…',
+        dragHandle: 'Drag handle',
+        turnInto: (label) => `Turn into ${label}`,
+        unknownBlock: (type) => `Unknown block: ${type}`,
+        blockAdded: (label) => `${label} added`,
+        blockDuplicated: 'Block duplicated',
+        blockDeleted: (label) => `${label} deleted`,
+        blockMovedUp: 'Block moved up',
+        blockMovedDown: 'Block moved down',
+        turnedInto: (label) => `Turned into ${label}`,
+        noBlocksMatch: (query) => `No blocks match “${query}”.`,
+        groupText: 'Text',
+        groupMedia: 'Media',
+        groupLayout: 'Layout',
+        blockParagraph: 'Paragraph',
+        blockParagraphDesc: 'Rich text with inline formatting.',
+        blockHeading: 'Heading',
+        blockHeadingDesc: 'A section title (H1–H4).',
+        blockList: 'List',
+        blockListDesc: 'Bulleted or numbered list.',
+        blockQuote: 'Quote',
+        blockQuoteDesc: 'A blockquote with optional citation.',
+        blockCode: 'Code',
+        blockCodeDesc: 'Preformatted, monospace code.',
+        blockImage: 'Image',
+        blockImageDesc: 'Upload or link an image.',
+        blockEmbed: 'Embed',
+        blockEmbedDesc: 'YouTube, Vimeo or any URL.',
+        blockButton: 'Button',
+        blockButtonDesc: 'A call-to-action link button.',
+        blockDivider: 'Divider',
+        blockDividerDesc: 'A horizontal separator.',
+        blockColumns: 'Columns',
+        blockColumnsDesc: 'A responsive multi-column layout.',
+        bold: 'Bold',
+        italic: 'Italic',
+        underline: 'Underline',
+        strikethrough: 'Strikethrough',
+        inlineCode: 'Inline code',
+        link: 'Link',
+        clearFormatting: 'Clear formatting',
+        linkUrlPrompt: 'Link URL',
+        editableText: 'Editable text',
+        headingPlaceholder: (level) => `Heading ${level}`,
+        headingLevelGroup: 'Heading level',
+        listStyle: 'List style',
+        bulleted: 'Bulleted',
+        numbered: 'Numbered',
+        listItem: 'List item',
+        quoteText: 'Quote text',
+        citation: 'Citation',
+        addCitation: '— Add a citation',
+        codeLanguage: 'Code language',
+        codeLanguagePlaceholder: 'language (optional)',
+        enterCode: 'Enter code…',
+        imageWidth: (percent) => `Width: ${percent}%`,
+        uploading: 'Uploading…',
+        dropImagePrompt: 'Drag & drop an image, or',
+        chooseFile: 'Choose file',
+        pasteImageUrl: '…or paste an image URL',
+        notAnImage: 'Please choose an image file.',
+        uploadFailed: 'Upload failed. Try again or paste a URL.',
+        imageAdded: 'Image added',
+        pasteEmbedUrl: 'Paste a YouTube, Vimeo or other URL…',
+        embedFallbackNote: 'That URL can’t be embedded, but it will render as a link.',
+        embedTitle: (provider) => `${provider} embed`,
+        embedAdded: (provider) => `${provider} embed added`,
+        embeddedContent: 'Embedded content',
+        buttonLabel: 'Label',
+        buttonLink: 'Link (href)',
+        buttonTone: 'Tone',
+        buttonVariant: 'Variant',
+        buttonDefaultLabel: 'Click me',
+        alignLeft: 'Left',
+        alignCenter: 'Center',
+        alignRight: 'Right',
+        tonePrimary: 'Primary',
+        toneNeutral: 'Neutral',
+        toneSuccess: 'Success',
+        toneWarning: 'Warning',
+        toneDanger: 'Danger',
+        toneInfo: 'Info',
+        variantSolid: 'Solid',
+        variantSoft: 'Soft',
+        variantOutline: 'Outline',
+        ratioEqual: 'Equal',
+        alignStretch: 'Stretch',
+        alignTop: 'Top',
+        alignMiddle: 'Middle',
+        alignBottom: 'Bottom',
+        justifyStart: 'Start',
+        justifyCenter: 'Center',
+        justifyEnd: 'End',
+        justifyBetween: 'Space between',
+    },
+};
+/**
+ * The active string map. Defaults to {@link MK_DEFAULT_I18N}; override with
+ * {@link provideMkI18n}. Inject it (`inject(MK_I18N)`) wherever a built-in
+ * string is rendered.
+ */
+const MK_I18N = new InjectionToken('MK_I18N', {
+    providedIn: 'root',
+    factory: () => MK_DEFAULT_I18N,
+});
+/**
+ * Provide localised strings (merged over the English defaults) — pass any
+ * subset. The nested `dateNames`, `blockEditor` and `validation` groups are
+ * merged deeply, so partial overrides of those work too.
+ *
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [provideMkI18n({ noResults: 'Brak wyników', close: 'Zamknij' })],
+ * });
+ * ```
+ */
+function provideMkI18n(overrides) {
+    const value = {
+        ...MK_DEFAULT_I18N,
+        ...overrides,
+        dateNames: { ...MK_DEFAULT_DATE_NAMES, ...overrides.dateNames },
+        blockEditor: { ...MK_DEFAULT_I18N.blockEditor, ...overrides.blockEditor },
+        validation: { ...MK_DEFAULT_VALIDATION, ...overrides.validation },
+    };
+    return { provide: MK_I18N, useValue: value };
+}
+/**
+ * Field context — the contract a field wrapper (`mk-form-field`) exposes to
+ * the control nested inside it. Controls inject it optionally
+ * (`inject(MkFieldContext, { optional: true })`) to adopt the wrapper's
+ * control id and to reflect its required/error state and `aria-describedby`
+ * wiring — without depending on the `@mk-kit/ui/forms` entry point.
+ *
+ * `MkFormField` provides itself under this token; standalone usage (no
+ * wrapper) simply yields `null`.
+ */
+class MkFieldContext {
+}
+/**
+ * Dependency-free syntax highlighting for {@link MkCodeEditor}. Each function
+ * takes source text and returns an HTML string of `<span class="mk-tok-…">`
+ * tokens. Input is HTML-escaped first, so the result is safe to render.
+ */
+/** Escape the three characters that could break out of HTML text content. */
+function mkEscapeHtml(src) {
+    return src.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * Highlight a JSON document. Recognises object keys, strings, numbers, the
+ * `true`/`false`/`null` literals and structural punctuation. Invalid JSON is
+ * still highlighted token-by-token (the editor validates separately).
+ */
+function mkHighlightJson(src) {
+    const esc = mkEscapeHtml(src);
+    return esc.replace(
+    // 1: string (+ optional following colon → key) · 2: colon
+    // 3: keyword · 4: number · 5: punctuation
+    /("(?:\\.|[^"\\])*")(\s*:)?|\b(true|false|null)\b|(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)|([{}\[\],:])/g, (match, str, colon, keyword, num, punc) => {
+        if (str !== undefined) {
+            if (colon !== undefined) {
+                return `<span class="mk-tok-key">${str}</span><span class="mk-tok-punc">${colon}</span>`;
+            }
+            return `<span class="mk-tok-str">${str}</span>`;
+        }
+        if (keyword !== undefined)
+            return `<span class="mk-tok-kw">${keyword}</span>`;
+        if (num !== undefined)
+            return `<span class="mk-tok-num">${num}</span>`;
+        if (punc !== undefined)
+            return `<span class="mk-tok-punc">${punc}</span>`;
+        return match;
+    });
+}
+/** Highlight `src` for `language`, falling back to escaped plain text. */
+function mkHighlight(src, language) {
+    return language === 'json' ? mkHighlightJson(src) : mkEscapeHtml(src);
+}
+/**
+ * Re-validates the bound form control whenever a validator's inputs change.
+ *
+ * A `Validator` whose constraints come from component inputs (`[min]`,
+ * `[max]`, `[required]`, …) must tell Angular when those inputs change,
+ * otherwise the control keeps the verdict computed under the old constraints.
+ * `NgModel`/`FormControlName` pass a callback to `registerOnValidatorChange`
+ * for exactly this; call it from an effect over the constraint signals.
+ *
+ * Must be called from an injection context (i.e. as a field initialiser).
+ *
+ * ```ts
+ * private readonly validatorChange = mkValidatorChange(() => {
+ *   this.min();
+ *   this.max();
+ * });
+ *
+ * registerOnValidatorChange(fn: () => void): void {
+ *   this.validatorChange.register(fn);
+ * }
+ * ```
+ *
+ * @param deps Reads every signal the validator depends on.
+ */
+function mkValidatorChange(deps) {
+    let onChange = () => { };
+    let primed = false;
+    effect(() => {
+        deps();
+        // Skip the effect's initial run: the control validates once on bind
+        // anyway, and re-entering validation during setup is wasted work.
+        if (!primed) {
+            primed = true;
+            return;
+        }
+        // The callback synchronously calls `updateValueAndValidity()`, which reads
+        // and writes signals — keep it out of this effect's dependency graph.
+        untracked(() => onChange());
+    });
+    return {
+        register(fn) {
+            onChange = fn;
+        },
+        notify() {
+            onChange();
+        },
+    };
+}
+/**
+ * Resolves the message for the first error on a control, mirroring how
+ * `mat-error` shows one message at a time.
+ *
+ * Lookup order per key: the field's `overrides`, then the i18n `validation`
+ * table, then the error payload's own `message` string (so a custom validator
+ * can carry its text), then the generic fallback. Keys are visited in the
+ * order the validators put them on the control, so composing
+ * `[Validators.required, Validators.email]` surfaces "required" while empty.
+ *
+ * @returns The message, or `null` when there are no errors.
+ */
+function mkFirstErrorMessage(errors, strings, overrides) {
+    if (!errors)
+        return null;
+    for (const key of Object.keys(errors)) {
+        const payload = errors[key];
+        const override = overrides?.[key];
+        if (typeof override === 'string')
+            return override;
+        if (typeof override === 'function')
+            return override(payload);
+        const builtin = strings[key];
+        if (typeof builtin === 'string')
+            return builtin;
+        if (typeof builtin === 'function')
+            return builtin(payload);
+        if (payload && typeof payload === 'object' && typeof payload.message === 'string') {
+            return payload.message;
+        }
+    }
+    return errors ? strings.unknown : null;
+}
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { MK_DEFAULT_DATE_NAMES, MK_DEFAULT_I18N, MK_DEFAULT_VALIDATION, MK_I18N, MK_OVERLAY_DATA, MkAnchoredPanel, MkFieldContext, MkFocusTrap, MkLiveAnnouncer, MkOverlayRef, MkOverlayService, MkThemeService, mkComputeAnchoredPosition, mkFirstErrorMessage, mkGetFocusable, mkHighlight, mkHighlightJson, mkUniqueId, mkValidatorChange, provideMkI18n };
+//# sourceMappingURL=mk-kit-ui-core.mjs.map