@raqm/ui 0.0.0-stage → 0.1.1

package/fesm2022/raqm-ui-tooltip.mjs

@@ -0,0 +1,1226 @@
+import { DOCUMENT, NgTemplateOutlet } from "@angular/common";
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, DestroyRef, Directive, ElementRef, InjectionToken, Injector, Renderer2, TemplateRef, ViewContainerRef, afterNextRender, booleanAttribute, computed, effect, inject, input, isDevMode, numberAttribute, signal, untracked, viewChild } from "@angular/core";
+import { Directionality } from "@angular/cdk/bidi";
+import { Overlay } from "@angular/cdk/overlay";
+import { ScrollDispatcher, ViewportRuler } from "@angular/cdk/scrolling";
+import { TemplatePortal } from "@angular/cdk/portal";
+import { registerOverlayOwnership } from "@raqm/ui/overlay-internal";
+const RAQM_TOOLTIP = new InjectionToken("RaqmTooltip");
+const RAQM_TOOLTIP_PROVIDER = new InjectionToken("RaqmTooltipProvider");
+var RaqmTooltipLifecycle = class {
+	host;
+	openRequested = false;
+	openReason = "mouse";
+	suppressFocusOpen = false;
+	providerRegistered = false;
+	constructor(host) {
+		this.host = host;
+	}
+	currentReason() {
+		return this.openReason;
+	}
+	requestOpen(ref, reason) {
+		if (ref !== this.host.slot.trigger()) return;
+		if (this.host.disabled() || ref.disabled) return;
+		if (reason === "focus" && this.suppressFocusOpen) return;
+		if (this.host.pane.open() || this.host.pane.hasPane) {
+			this.host.timers.cancelHoverClose();
+			if (reason === "focus") this.openReason = "focus";
+			return;
+		}
+		if (!this.host.slot.canOpen()) {
+			this.openRequested = true;
+			this.openReason = reason;
+			return;
+		}
+		this.openRequested = true;
+		this.openReason = reason;
+		this.host.timers.cancelOpen();
+		if (reason === "focus") {
+			this.host.timers.cancelHoverClose();
+			this.beginOpen("focus");
+			return;
+		}
+		const delay = this.host.delay();
+		if (delay > 0) {
+			this.host.timers.armOpen(delay);
+			return;
+		}
+		this.beginOpen("mouse");
+	}
+	requestClose(ref, reason) {
+		if (ref !== this.host.slot.trigger()) return;
+		this.openRequested = false;
+		this.host.timers.cancelOpen();
+		if (reason === "focus") {
+			this.suppressFocusOpen = false;
+			this.host.timers.cancelHoverClose();
+			if (this.host.pane.open() || this.host.pane.hasPane) this.beginClose(false);
+			return;
+		}
+		if (reason === "mouse") {
+			if (!this.host.pane.open()) return;
+			if (this.openReason === "focus" && this.host.slot.isTriggerFocused()) return;
+			this.host.timers.scheduleHoverClose();
+			return;
+		}
+		this.suppressFocusOpen = true;
+		this.host.timers.cancelHoverClose();
+		if (!this.host.pane.open()) return;
+		this.beginClose(false);
+	}
+	closeNow() {
+		this.openRequested = false;
+		this.host.timers.cancelOpen();
+		this.host.timers.cancelHoverClose();
+		if (this.host.pane.open() || this.host.pane.hasPane) this.beginClose(true);
+	}
+	closeForPeer() {
+		this.closeNow();
+	}
+	claimActive() {
+		this.host.provider?.registerActive(this);
+		this.providerRegistered = true;
+	}
+	retryRequestedOpen() {
+		if (!this.openRequested || this.host.destroyed() || this.host.pane.hasPane) return;
+		if (!this.host.slot.canOpen()) return;
+		this.beginOpen(this.openReason);
+	}
+	onOpenElapsed() {
+		const trigger = this.host.slot.trigger();
+		if (this.openRequested && !this.host.destroyed() && trigger !== null) {
+			if (trigger.disabled) {
+				this.openRequested = false;
+				return;
+			}
+			this.beginOpen("mouse");
+		}
+	}
+	handleDetached(overlayRef) {
+		if (!this.host.pane.owns(overlayRef)) return;
+		this.host.pane.releaseOwnership();
+		this.openRequested = false;
+		this.host.pane.open.set(false);
+		this.host.pane.tooltipId.set(null);
+		this.host.pane.closing.set(false);
+		this.host.position.clear();
+		this.host.timers.cancelOpen();
+		this.host.timers.cancelHoverClose();
+		this.clearProviderRegistration();
+		this.host.pane.releaseSubscriptions();
+	}
+	destroy() {
+		this.openRequested = false;
+		this.host.timers.cancelOpen();
+		this.host.timers.cancelHoverClose();
+		this.host.pane.releaseSubscriptions();
+		const { pending, overlay } = this.host.pane.takeForDestroy();
+		this.clearProviderRegistration();
+		pending?.dispose();
+		overlay?.dispose();
+	}
+	beginOpen(reason) {
+		const trigger = this.host.slot.trigger();
+		const content = this.host.slot.content();
+		const panel = this.host.panel();
+		if (this.host.destroyed() || this.host.disabled() || trigger === null || trigger.disabled || content === null || panel === void 0 || this.host.pane.hasPane) return;
+		this.openRequested = true;
+		this.openReason = reason;
+		this.host.timers.removePendingEscape();
+		this.host.pane.flushPendingDispose();
+		this.host.timers.cancelHoverClose();
+		this.host.pane.openLayer(trigger, panel);
+	}
+	beginClose(immediate) {
+		this.openRequested = false;
+		this.host.pane.open.set(false);
+		this.host.pane.tooltipId.set(null);
+		this.host.timers.cancelOpen();
+		this.host.timers.cancelHoverClose();
+		this.clearProviderRegistration();
+		this.host.pane.disposePane(immediate);
+	}
+	clearProviderRegistration() {
+		if (this.providerRegistered) {
+			this.host.provider?.clearActive(this);
+			this.providerRegistered = false;
+		}
+	}
+};
+const SIDES = [
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"inline-start",
+	"inline-end"
+];
+const ALIGNS = [
+	"start",
+	"center",
+	"end"
+];
+const DEFAULT_ALIGN = "center";
+const PANE_CLASS = "raqm-tooltip-overlay-pane";
+const CONTENT_CLASS = "raqm-tooltip-content";
+const CONTENT_ENTERING_CLASS = "raqm-tooltip-content--entering";
+const CONTENT_CLOSING_CLASS = "raqm-tooltip-content--closing";
+let nextTooltipId = 0;
+function nextTooltipRootId() {
+	return `raqm-tooltip-${++nextTooltipId}`;
+}
+function prefersReducedMotion() {
+	return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function toSide(value) {
+	return SIDES.includes(value) ? value : "top";
+}
+function toAlign(value) {
+	return ALIGNS.includes(value) ? value : DEFAULT_ALIGN;
+}
+function toDir(value) {
+	return value === "ltr" || value === "rtl" ? value : void 0;
+}
+function toOffset(fallback) {
+	return (value) => {
+		const parsed = numberAttribute(value, fallback);
+		return Number.isFinite(parsed) ? parsed : fallback;
+	};
+}
+var RaqmTooltipPane = class {
+	overlay;
+	viewportRuler;
+	scrollDispatcher;
+	document;
+	viewContainerRef;
+	position;
+	host;
+	open = signal(false, ...ngDevMode ? [{ debugName: "open" }] : /* istanbul ignore next */ []);
+	tooltipId = signal(null, ...ngDevMode ? [{ debugName: "tooltipId" }] : /* istanbul ignore next */ []);
+	closing = signal(false, ...ngDevMode ? [{ debugName: "closing" }] : /* istanbul ignore next */ []);
+	rootId = nextTooltipRootId();
+	overlayRef;
+	generation = 0;
+	exitTimer;
+	pendingDisposeOverlay;
+	detachSubscription;
+	outsideSubscription;
+	viewportSubscription;
+	scrollSubscription;
+	escapeListener;
+	constructor(overlay, viewportRuler, scrollDispatcher, document, viewContainerRef, position, host) {
+		this.overlay = overlay;
+		this.viewportRuler = viewportRuler;
+		this.scrollDispatcher = scrollDispatcher;
+		this.document = document;
+		this.viewContainerRef = viewContainerRef;
+		this.position = position;
+		this.host = host;
+	}
+	get hasPane() {
+		return this.overlayRef !== void 0;
+	}
+	get ref() {
+		return this.overlayRef;
+	}
+	owns(overlayRef) {
+		return this.overlayRef === overlayRef;
+	}
+	openLayer(trigger, panel) {
+		const generation = ++this.generation;
+		const preferred = this.position.beginPlacement();
+		this.host.claimActive();
+		const strategy = this.position.buildStrategy(trigger.element, preferred);
+		const config = {
+			positionStrategy: strategy,
+			hasBackdrop: false,
+			scrollStrategy: this.overlay.scrollStrategies.noop(),
+			panelClass: [PANE_CLASS],
+			disposeOnNavigation: true,
+			direction: this.position.direction
+		};
+		const overlayRef = this.overlay.create(config);
+		registerOverlayOwnership(trigger.element, overlayRef);
+		this.overlayRef = overlayRef;
+		this.position.watchSide(strategy, overlayRef);
+		this.outsideSubscription = overlayRef.outsidePointerEvents().subscribe((event) => {
+			if (event.button === 0) this.host.onOutsidePress(trigger);
+		});
+		this.detachSubscription = overlayRef.detachments().subscribe(() => this.host.onDetached(overlayRef));
+		this.viewportSubscription = this.viewportRuler.change(0).subscribe(() => this.position.reposition());
+		this.scrollSubscription = this.scrollDispatcher.ancestorScrolled(trigger.element, 0).subscribe(() => this.position.reposition());
+		this.escapeListener = (event) => {
+			if (event.key !== "Escape" || !this.open()) return;
+			this.host.onEscape(trigger);
+		};
+		this.document.addEventListener("keydown", this.escapeListener);
+		overlayRef.attach(new TemplatePortal(panel, this.viewContainerRef));
+		overlayRef.overlayElement.style.visibility = "hidden";
+		overlayRef.overlayElement.style.pointerEvents = "none";
+		this.open.set(true);
+		this.tooltipId.set(this.rootId);
+		this.position.attachResizeObserver(trigger.element, overlayRef);
+		afterNextRender(() => {
+			if (generation !== this.generation || this.overlayRef !== overlayRef) return;
+			this.position.reposition();
+			this.reveal(overlayRef);
+		}, { injector: this.host.injector });
+	}
+	reposition() {
+		this.position.reposition();
+	}
+	releaseOwnership() {
+		this.overlayRef = void 0;
+		this.position.discard();
+	}
+	invalidate() {
+		this.generation += 1;
+	}
+	disposePane(immediate) {
+		const overlayRef = this.overlayRef;
+		this.overlayRef = void 0;
+		this.position.reset();
+		this.releaseSubscriptions();
+		if (!overlayRef) {
+			this.closing.set(false);
+			return;
+		}
+		overlayRef.overlayElement.setAttribute("inert", "");
+		overlayRef.overlayElement.setAttribute("aria-hidden", "true");
+		if (immediate || prefersReducedMotion()) {
+			this.closing.set(false);
+			overlayRef.dispose();
+			return;
+		}
+		const surface = overlayRef.overlayElement.querySelector(`.${CONTENT_CLASS}`);
+		surface?.classList.remove(CONTENT_ENTERING_CLASS);
+		surface?.classList.add(CONTENT_CLOSING_CLASS);
+		this.closing.set(true);
+		this.pendingDisposeOverlay = overlayRef;
+		this.exitTimer = setTimeout(() => {
+			this.exitTimer = void 0;
+			this.pendingDisposeOverlay = void 0;
+			this.closing.set(false);
+			overlayRef.dispose();
+		}, 150);
+	}
+	flushPendingDispose() {
+		if (this.exitTimer !== void 0) {
+			clearTimeout(this.exitTimer);
+			this.exitTimer = void 0;
+		}
+		this.closing.set(false);
+		const pending = this.pendingDisposeOverlay;
+		this.pendingDisposeOverlay = void 0;
+		pending?.dispose();
+	}
+	reveal(overlayRef) {
+		const surface = overlayRef.overlayElement.querySelector(`.${CONTENT_CLASS}`);
+		if (!surface || this.overlayRef !== overlayRef) return;
+		surface.classList.remove(CONTENT_CLOSING_CLASS);
+		surface.classList.add(CONTENT_ENTERING_CLASS);
+		overlayRef.overlayElement.style.pointerEvents = "";
+		overlayRef.overlayElement.style.visibility = "";
+	}
+	takeForDestroy() {
+		if (this.exitTimer !== void 0) {
+			clearTimeout(this.exitTimer);
+			this.exitTimer = void 0;
+		}
+		const pending = this.pendingDisposeOverlay;
+		this.pendingDisposeOverlay = void 0;
+		const overlayRef = this.overlayRef;
+		this.overlayRef = void 0;
+		this.position.discard();
+		this.closing.set(false);
+		this.open.set(false);
+		this.tooltipId.set(null);
+		return {
+			pending,
+			overlay: overlayRef
+		};
+	}
+	releaseSubscriptions() {
+		this.position.releaseSide();
+		this.detachSubscription?.unsubscribe();
+		this.detachSubscription = void 0;
+		this.outsideSubscription?.unsubscribe();
+		this.outsideSubscription = void 0;
+		this.viewportSubscription?.unsubscribe();
+		this.viewportSubscription = void 0;
+		this.scrollSubscription?.unsubscribe();
+		this.scrollSubscription = void 0;
+		this.position.releaseResizeObserver();
+		if (this.escapeListener !== void 0) {
+			this.document.removeEventListener("keydown", this.escapeListener);
+			this.escapeListener = void 0;
+		}
+	}
+};
+function layoutBox(element) {
+	const parent = element.offsetParent;
+	if (!parent) {
+		const rect = element.getBoundingClientRect();
+		return {
+			left: rect.left,
+			top: rect.top,
+			width: rect.width,
+			height: rect.height
+		};
+	}
+	const parentRect = parent.getBoundingClientRect();
+	return {
+		left: parentRect.left + parent.clientLeft + element.offsetLeft,
+		top: parentRect.top + parent.clientTop + element.offsetTop,
+		width: element.offsetWidth,
+		height: element.offsetHeight
+	};
+}
+var RaqmTooltipPosition = class {
+	overlay;
+	host;
+	panelDir = signal("ltr", ...ngDevMode ? [{ debugName: "panelDir" }] : /* istanbul ignore next */ []);
+	resolvedSide = signal("top", ...ngDevMode ? [{ debugName: "resolvedSide" }] : /* istanbul ignore next */ []);
+	positionStrategy;
+	currentPositions = [];
+	currentSides = [];
+	currentAppliedSide = "top";
+	currentDir = "ltr";
+	sideSubscription;
+	resizeObserver;
+	constructor(overlay, host) {
+		this.overlay = overlay;
+		this.host = host;
+	}
+	get direction() {
+		return this.currentDir;
+	}
+	beginPlacement() {
+		const dir = this.readResolvedDir();
+		this.currentDir = dir;
+		this.panelDir.set(dir);
+		const preferred = this.resolvePhysicalSide(this.host.side());
+		this.currentAppliedSide = preferred;
+		this.resolvedSide.set(preferred);
+		return preferred;
+	}
+	buildStrategy(origin, preferred) {
+		const strategy = this.overlay.position().flexibleConnectedTo(origin);
+		strategy.withFlexibleDimensions(false).withGrowAfterOpen(false).withPush(true).withViewportMargin(5);
+		this.setPositions(strategy, [preferred, this.oppositeSide(preferred)]);
+		this.positionStrategy = strategy;
+		return strategy;
+	}
+	reposition() {
+		const overlayRef = this.host.pane();
+		const strategy = this.positionStrategy;
+		if (!overlayRef || !strategy) return;
+		const dir = this.readResolvedDir();
+		if (dir !== this.currentDir) {
+			this.currentDir = dir;
+			this.panelDir.set(dir);
+			overlayRef.setDirection(dir);
+		}
+		const preferred = this.resolvePhysicalSide(this.host.side());
+		this.setPositions(strategy, [preferred, this.oppositeSide(preferred)]);
+		overlayRef.updatePosition();
+		this.positionArrow(this.currentAppliedSide);
+	}
+	watchSide(strategy, overlayRef) {
+		this.sideSubscription = strategy.positionChanges.subscribe((change) => {
+			const index = this.currentPositions.indexOf(change.connectionPair);
+			const side = this.currentSides[index] ?? this.currentSides[0] ?? this.resolvedSide();
+			this.currentAppliedSide = side;
+			this.resolvedSide.set(side);
+			const surface = overlayRef.overlayElement.querySelector(`.${CONTENT_CLASS}`);
+			surface?.setAttribute("data-raqm-side", side);
+			this.positionArrow(side, surface ?? void 0);
+		});
+	}
+	setPositions(strategy, sides) {
+		this.currentSides = [...sides];
+		this.currentPositions = sides.map((side) => this.buildPositionFor(side));
+		strategy.withPositions(this.currentPositions);
+	}
+	buildPositionFor(side) {
+		const align = this.host.align();
+		const x = align;
+		const y = this.toVerticalAlign(align);
+		const mainOffset = this.signedSideOffset(side);
+		switch (side) {
+			case "bottom": return {
+				originX: x,
+				originY: "bottom",
+				overlayX: x,
+				overlayY: "top",
+				offsetX: this.host.alignOffset(),
+				offsetY: mainOffset
+			};
+			case "left": return this.horizontalPosition("left", y, mainOffset);
+			case "right": return this.horizontalPosition("right", y, mainOffset);
+			default: return {
+				originX: x,
+				originY: "top",
+				overlayX: x,
+				overlayY: "bottom",
+				offsetX: this.host.alignOffset(),
+				offsetY: mainOffset
+			};
+		}
+	}
+	horizontalPosition(side, alignY, offsetX) {
+		const rtl = this.currentDir === "rtl";
+		return {
+			originX: side === "right" ? rtl ? "start" : "end" : rtl ? "end" : "start",
+			originY: alignY,
+			overlayX: side === "right" ? rtl ? "end" : "start" : rtl ? "start" : "end",
+			overlayY: alignY,
+			offsetX,
+			offsetY: this.host.alignOffset()
+		};
+	}
+	signedSideOffset(side) {
+		return side === "bottom" || side === "right" ? this.host.sideOffset() : -this.host.sideOffset();
+	}
+	toVerticalAlign(align) {
+		return align === "start" ? "top" : align === "end" ? "bottom" : "center";
+	}
+	resolvePhysicalSide(side) {
+		switch (side) {
+			case "inline-start": return this.currentDir === "rtl" ? "right" : "left";
+			case "inline-end": return this.currentDir === "rtl" ? "left" : "right";
+			default: return side;
+		}
+	}
+	oppositeSide(side) {
+		switch (side) {
+			case "top": return "bottom";
+			case "bottom": return "top";
+			case "left": return "right";
+			default: return "left";
+		}
+	}
+	positionArrow(side, surface) {
+		const content = surface ?? this.host.pane()?.overlayElement.querySelector(`.raqm-tooltip-content`);
+		const trigger = this.host.anchor();
+		if (!content || !trigger) return;
+		const contentRect = layoutBox(content);
+		const triggerRect = trigger.getBoundingClientRect();
+		const vertical = side === "top" || side === "bottom";
+		const size = vertical ? contentRect.width : contentRect.height;
+		const center = vertical ? triggerRect.left + triggerRect.width / 2 - contentRect.left : triggerRect.top + triggerRect.height / 2 - contentRect.top;
+		if (size <= 0) return;
+		const edge = Math.min(12, size / 2);
+		const offset = Math.max(edge, Math.min(center, size - edge));
+		content.style.setProperty("--raqm-tooltip-arrow-offset", `${offset}px`);
+	}
+	readResolvedDir() {
+		const explicit = this.host.dir();
+		if (explicit === "ltr" || explicit === "rtl") return explicit;
+		const computedStyle = getComputedStyle(this.host.element).direction;
+		if (computedStyle === "rtl") return "rtl";
+		if (computedStyle === "ltr") return "ltr";
+		return this.host.directionality?.value ?? "ltr";
+	}
+	attachResizeObserver(trigger, overlayRef) {
+		if (typeof ResizeObserver === "undefined") return;
+		this.resizeObserver?.disconnect();
+		const observer = new ResizeObserver(() => {
+			if (this.host.pane() === overlayRef) this.reposition();
+		});
+		this.resizeObserver = observer;
+		observer.observe(trigger);
+		const surface = overlayRef.overlayElement.querySelector(`.${CONTENT_CLASS}`);
+		if (surface) observer.observe(surface);
+	}
+	releaseSide() {
+		this.sideSubscription?.unsubscribe();
+		this.sideSubscription = void 0;
+	}
+	releaseResizeObserver() {
+		if (this.resizeObserver !== void 0) {
+			this.resizeObserver.disconnect();
+			this.resizeObserver = void 0;
+		}
+	}
+	reset() {
+		this.positionStrategy = void 0;
+		this.currentPositions = [];
+		this.currentSides = [];
+	}
+	discard() {
+		this.positionStrategy = void 0;
+	}
+	clear() {
+		this.currentPositions = [];
+		this.currentSides = [];
+	}
+};
+var RaqmTooltipSlot = class {
+	document;
+	host;
+	triggerRef = signal(null, ...ngDevMode ? [{ debugName: "triggerRef" }] : /* istanbul ignore next */ []);
+	contentTemplate = signal(null, ...ngDevMode ? [{ debugName: "contentTemplate" }] : /* istanbul ignore next */ []);
+	canOpen = computed(() => this.triggerRef() !== null && this.contentTemplate() !== null && this.host.panel() !== void 0, ...ngDevMode ? [{ debugName: "canOpen" }] : /* istanbul ignore next */ []);
+	constructor(document, host) {
+		this.document = document;
+		this.host = host;
+	}
+	trigger() {
+		return this.triggerRef();
+	}
+	content() {
+		return this.contentTemplate();
+	}
+	registerTrigger(ref) {
+		const current = this.triggerRef();
+		if (current !== null && current !== ref) {
+			if (isDevMode()) console.error("[raqm-tooltip] Only one `[raqm-tooltip-trigger]` is supported per <raqm-tooltip>; the extra trigger is ignored.");
+			return;
+		}
+		this.triggerRef.set(ref);
+		this.host.onChanged();
+	}
+	unregisterTrigger(ref) {
+		if (this.triggerRef() !== ref) return;
+		this.triggerRef.set(null);
+		this.host.onLost();
+	}
+	registerContent(template) {
+		const current = this.contentTemplate();
+		if (current !== null && current !== template) {
+			if (isDevMode()) console.error("[raqm-tooltip] Only one `ng-template[raqm-tooltip-content]` is supported per <raqm-tooltip>; the extra template is ignored.");
+			return;
+		}
+		this.contentTemplate.set(template);
+		this.host.onChanged();
+	}
+	unregisterContent(template) {
+		if (this.contentTemplate() !== template) return;
+		this.contentTemplate.set(null);
+		this.host.onLost();
+	}
+	isTriggerFocused() {
+		const trigger = this.triggerRef();
+		return trigger !== null && this.document.activeElement === trigger.element;
+	}
+};
+var RaqmTooltipTimers = class {
+	document;
+	host;
+	openTimer;
+	hoverCloseTimer;
+	pendingEscapeListener;
+	constructor(document, host) {
+		this.document = document;
+		this.host = host;
+	}
+	armOpen(delay) {
+		this.openTimer = setTimeout(() => {
+			this.openTimer = void 0;
+			this.removePendingEscape();
+			this.host.onOpenElapsed();
+		}, delay);
+		this.armPendingEscape();
+	}
+	cancelOpen() {
+		if (this.openTimer !== void 0) {
+			clearTimeout(this.openTimer);
+			this.openTimer = void 0;
+		}
+		this.removePendingEscape();
+	}
+	cancelHoverClose() {
+		if (this.hoverCloseTimer !== void 0) {
+			clearTimeout(this.hoverCloseTimer);
+			this.hoverCloseTimer = void 0;
+		}
+	}
+	scheduleHoverClose() {
+		if (!this.host.open() || this.host.openReason() === "focus" || this.hoverCloseTimer !== void 0) return;
+		this.hoverCloseTimer = setTimeout(() => {
+			this.hoverCloseTimer = void 0;
+			if (!this.host.destroyed() && this.host.open()) this.host.onHoverElapsed();
+		}, 100);
+	}
+	removePendingEscape() {
+		if (this.pendingEscapeListener !== void 0) {
+			this.document.removeEventListener("keydown", this.pendingEscapeListener);
+			this.pendingEscapeListener = void 0;
+		}
+	}
+	armPendingEscape() {
+		this.removePendingEscape();
+		const trigger = this.host.trigger();
+		if (trigger === null) return;
+		this.pendingEscapeListener = (event) => {
+			if (event.key !== "Escape") return;
+			this.host.onEscape(trigger);
+		};
+		this.document.addEventListener("keydown", this.pendingEscapeListener);
+	}
+};
+var RaqmTooltipComponent = class RaqmTooltipComponent {
+	host = inject(ElementRef);
+	overlay = inject(Overlay);
+	viewContainerRef = inject(ViewContainerRef);
+	injector = inject(Injector);
+	directionality = inject(Directionality, { optional: true });
+	viewportRuler = inject(ViewportRuler);
+	scrollDispatcher = inject(ScrollDispatcher);
+	document = inject(DOCUMENT);
+	provider = inject(RAQM_TOOLTIP_PROVIDER, { optional: true });
+	panelTemplate = viewChild("panel", {
+		...ngDevMode ? { debugName: "panelTemplate" } : /* istanbul ignore next */ {},
+		read: TemplateRef
+	});
+	disabled = input(false, {
+		...ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {},
+		transform: booleanAttribute
+	});
+	side = input("top", {
+		...ngDevMode ? { debugName: "side" } : /* istanbul ignore next */ {},
+		transform: toSide
+	});
+	align = input(DEFAULT_ALIGN, {
+		...ngDevMode ? { debugName: "align" } : /* istanbul ignore next */ {},
+		transform: toAlign
+	});
+	sideOffset = input(4, {
+		...ngDevMode ? { debugName: "sideOffset" } : /* istanbul ignore next */ {},
+		transform: toOffset(4)
+	});
+	alignOffset = input(0, {
+		...ngDevMode ? { debugName: "alignOffset" } : /* istanbul ignore next */ {},
+		transform: toOffset(0)
+	});
+	dir = input(void 0, {
+		...ngDevMode ? { debugName: "dir" } : /* istanbul ignore next */ {},
+		transform: toDir
+	});
+	position = new RaqmTooltipPosition(this.overlay, {
+		element: this.host.nativeElement,
+		directionality: this.directionality,
+		side: () => this.side(),
+		align: () => this.align(),
+		sideOffset: () => this.sideOffset(),
+		alignOffset: () => this.alignOffset(),
+		dir: () => this.dir(),
+		anchor: () => this.slot.trigger()?.element ?? null,
+		pane: () => this.pane.ref
+	});
+	pane = new RaqmTooltipPane(this.overlay, this.viewportRuler, this.scrollDispatcher, this.document, this.viewContainerRef, this.position, {
+		injector: this.injector,
+		claimActive: () => this.lifecycle.claimActive(),
+		onOutsidePress: (trigger) => this.lifecycle.requestClose(trigger, "press"),
+		onEscape: (trigger) => this.lifecycle.requestClose(trigger, "escape"),
+		onDetached: (overlayRef) => this.lifecycle.handleDetached(overlayRef)
+	});
+	slot = new RaqmTooltipSlot(this.document, {
+		panel: () => this.panelTemplate(),
+		onChanged: () => this.lifecycle.retryRequestedOpen(),
+		onLost: () => this.lifecycle.closeForPeer()
+	});
+	timers = new RaqmTooltipTimers(this.document, {
+		open: () => this.open(),
+		openReason: () => this.lifecycle.currentReason(),
+		destroyed: () => this.destroyed,
+		trigger: () => this.slot.trigger(),
+		onOpenElapsed: () => this.lifecycle.onOpenElapsed(),
+		onHoverElapsed: () => this.lifecycle.beginClose(false),
+		onEscape: (trigger) => this.lifecycle.requestClose(trigger, "escape")
+	});
+	lifecycle = new RaqmTooltipLifecycle({
+		pane: this.pane,
+		position: this.position,
+		slot: this.slot,
+		timers: this.timers,
+		provider: this.provider,
+		disabled: () => this.disabled(),
+		destroyed: () => this.destroyed,
+		delay: () => this.delay(),
+		panel: () => this.panelTemplate()
+	});
+	delay = computed(() => this.provider?.delay() ?? 0, ...ngDevMode ? [{ debugName: "delay" }] : /* istanbul ignore next */ []);
+	destroyed = false;
+	open = this.pane.open;
+	tooltipId = this.pane.tooltipId;
+	contentTemplate = this.slot.contentTemplate;
+	panelDir = this.position.panelDir;
+	resolvedSide = this.position.resolvedSide;
+	closing = this.pane.closing;
+	constructor() {
+		effect(() => {
+			const disabled = this.disabled();
+			untracked(() => {
+				if (!disabled) return;
+				this.lifecycle.closeNow();
+			});
+		});
+		effect(() => {
+			this.side();
+			this.align();
+			this.sideOffset();
+			this.alignOffset();
+			this.dir();
+			untracked(() => this.applyPositionInputs());
+		});
+	}
+	ngOnDestroy() {
+		this.destroyed = true;
+		this.pane.invalidate();
+		this.lifecycle.destroy();
+	}
+	registerTrigger(ref) {
+		this.slot.registerTrigger(ref);
+	}
+	unregisterTrigger(ref) {
+		this.slot.unregisterTrigger(ref);
+	}
+	registerContent(template) {
+		this.slot.registerContent(template);
+	}
+	unregisterContent(template) {
+		this.slot.unregisterContent(template);
+	}
+	requestOpen(ref, reason) {
+		this.lifecycle.requestOpen(ref, reason);
+	}
+	requestClose(ref, reason) {
+		this.lifecycle.requestClose(ref, reason);
+	}
+	cancelHoverClose() {
+		this.timers.cancelHoverClose();
+	}
+	scheduleHoverClose() {
+		this.timers.scheduleHoverClose();
+	}
+	closeForPeer() {
+		this.lifecycle.closeForPeer();
+	}
+	onContentPointerEnter(event) {
+		if (event.pointerType === "mouse") this.timers.cancelHoverClose();
+	}
+	onContentPointerLeave(event) {
+		if (event.pointerType === "mouse") this.timers.scheduleHoverClose();
+	}
+	applyPositionInputs() {
+		if (this.pane.hasPane) this.pane.reposition();
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RaqmTooltipComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.2.0",
+		version: "22.2.2",
+		type: RaqmTooltipComponent,
+		isStandalone: true,
+		selector: "raqm-tooltip",
+		inputs: {
+			disabled: {
+				classPropertyName: "disabled",
+				publicName: "disabled",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			side: {
+				classPropertyName: "side",
+				publicName: "side",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			align: {
+				classPropertyName: "align",
+				publicName: "align",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			sideOffset: {
+				classPropertyName: "sideOffset",
+				publicName: "sideOffset",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			alignOffset: {
+				classPropertyName: "alignOffset",
+				publicName: "alignOffset",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			dir: {
+				classPropertyName: "dir",
+				publicName: "dir",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		providers: [{
+			provide: RAQM_TOOLTIP,
+			useExisting: RaqmTooltipComponent
+		}],
+		viewQueries: [{
+			propertyName: "panelTemplate",
+			first: true,
+			predicate: ["panel"],
+			descendants: true,
+			read: TemplateRef,
+			isSignal: true
+		}],
+		exportAs: ["raqmTooltip"],
+		ngImport: i0,
+		template: "<!-- One `button[raqm-tooltip-trigger]` (or passive span for a disabled button) plus one\r\n     `ng-template[raqm-tooltip-content]`; the root never wraps or clones the trigger. -->\r\n<ng-content />\r\n\r\n<ng-template #panel>\r\n  <div\r\n    class=\"raqm-tooltip-content\"\r\n    role=\"tooltip\"\r\n    [attr.id]=\"tooltipId()\"\r\n    [attr.dir]=\"panelDir()\"\r\n    [attr.data-raqm-side]=\"resolvedSide()\"\r\n    [class.raqm-tooltip-content--closing]=\"closing()\"\r\n    (pointerenter)=\"onContentPointerEnter($event)\"\r\n    (pointerleave)=\"onContentPointerLeave($event)\"\r\n  >\r\n    <ng-container [ngTemplateOutlet]=\"contentTemplate()\" />\r\n\r\n    <!-- The decorative diamond arrow is inert and never part of the description. -->\r\n    <span class=\"raqm-tooltip-arrow\" aria-hidden=\"true\"></span>\r\n  </div>\r\n</ng-template>\r\n",
+		styles: [":host{display:contents}.raqm-tooltip-content{position:relative;display:inline-flex;align-items:center;gap:calc(var(--raqm-spacing) * 1.5);box-sizing:border-box;inline-size:fit-content;max-inline-size:20rem;padding:calc(var(--raqm-spacing) * 1.5) calc(var(--raqm-spacing) * 3);border-radius:var(--raqm-radius-md);background-color:var(--raqm-foreground);color:var(--raqm-background);font-size:var(--raqm-font-size-xs);line-height:1rem;overflow-wrap:anywhere;z-index:50;isolation:isolate}.raqm-tooltip-arrow{position:absolute;inline-size:calc(var(--raqm-spacing) * 2.5);block-size:calc(var(--raqm-spacing) * 2.5);border-radius:2px;background-color:var(--raqm-foreground);pointer-events:none;z-index:50}.raqm-tooltip-content[data-raqm-side=top] .raqm-tooltip-arrow{bottom:calc(var(--raqm-spacing) * -2.5);left:var(--raqm-tooltip-arrow-offset, 50%);translate:-50% calc(-50% - 2px);rotate:45deg}.raqm-tooltip-content[data-raqm-side=bottom] .raqm-tooltip-arrow{top:var(--raqm-spacing);left:var(--raqm-tooltip-arrow-offset, 50%);translate:-50% calc(-50% - 2px);rotate:45deg}.raqm-tooltip-content[data-raqm-side=left] .raqm-tooltip-arrow{right:calc(var(--raqm-spacing) * -1);top:var(--raqm-tooltip-arrow-offset, 50%);translate:0 -50%;rotate:45deg}.raqm-tooltip-content[data-raqm-side=right] .raqm-tooltip-arrow{left:calc(var(--raqm-spacing) * -1);top:var(--raqm-tooltip-arrow-offset, 50%);translate:0 -50%;rotate:45deg}.raqm-tooltip-content--entering{animation:raqm-tooltip-in var(--raqm-duration-base) ease}.raqm-tooltip-content[data-raqm-side=bottom]{--raqm-tooltip-enter-translate: translateY(-8px)}.raqm-tooltip-content[data-raqm-side=top]{--raqm-tooltip-enter-translate: translateY(8px)}.raqm-tooltip-content[data-raqm-side=left]{--raqm-tooltip-enter-translate: translateX(8px)}.raqm-tooltip-content[data-raqm-side=right]{--raqm-tooltip-enter-translate: translateX(-8px)}@keyframes raqm-tooltip-in{0%{opacity:0;transform:var(--raqm-tooltip-enter-translate, none) scale(.95)}to{opacity:1;transform:none}}.raqm-tooltip-content--closing{opacity:0;transform:scale(.95);transition:opacity var(--raqm-duration-base) ease,transform var(--raqm-duration-base) ease}@media(prefers-reduced-motion:reduce){.raqm-tooltip-content,.raqm-tooltip-content--closing{animation:none;transition:none}}@media(forced-colors:active){.raqm-tooltip-content{border:1px solid CanvasText;background-color:CanvasText;color:Canvas}.raqm-tooltip-arrow{background-color:CanvasText}}\n"],
+		dependencies: [{
+			kind: "directive",
+			type: NgTemplateOutlet,
+			selector: "[ngTemplateOutlet]",
+			inputs: [
+				"ngTemplateOutletContext",
+				"ngTemplateOutlet",
+				"ngTemplateOutletInjector"
+			]
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: RaqmTooltipComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "raqm-tooltip",
+			imports: [NgTemplateOutlet],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			exportAs: "raqmTooltip",
+			providers: [{
+				provide: RAQM_TOOLTIP,
+				useExisting: RaqmTooltipComponent
+			}],
+			template: "<!-- One `button[raqm-tooltip-trigger]` (or passive span for a disabled button) plus one\r\n     `ng-template[raqm-tooltip-content]`; the root never wraps or clones the trigger. -->\r\n<ng-content />\r\n\r\n<ng-template #panel>\r\n  <div\r\n    class=\"raqm-tooltip-content\"\r\n    role=\"tooltip\"\r\n    [attr.id]=\"tooltipId()\"\r\n    [attr.dir]=\"panelDir()\"\r\n    [attr.data-raqm-side]=\"resolvedSide()\"\r\n    [class.raqm-tooltip-content--closing]=\"closing()\"\r\n    (pointerenter)=\"onContentPointerEnter($event)\"\r\n    (pointerleave)=\"onContentPointerLeave($event)\"\r\n  >\r\n    <ng-container [ngTemplateOutlet]=\"contentTemplate()\" />\r\n\r\n    <!-- The decorative diamond arrow is inert and never part of the description. -->\r\n    <span class=\"raqm-tooltip-arrow\" aria-hidden=\"true\"></span>\r\n  </div>\r\n</ng-template>\r\n",
+			styles: [":host{display:contents}.raqm-tooltip-content{position:relative;display:inline-flex;align-items:center;gap:calc(var(--raqm-spacing) * 1.5);box-sizing:border-box;inline-size:fit-content;max-inline-size:20rem;padding:calc(var(--raqm-spacing) * 1.5) calc(var(--raqm-spacing) * 3);border-radius:var(--raqm-radius-md);background-color:var(--raqm-foreground);color:var(--raqm-background);font-size:var(--raqm-font-size-xs);line-height:1rem;overflow-wrap:anywhere;z-index:50;isolation:isolate}.raqm-tooltip-arrow{position:absolute;inline-size:calc(var(--raqm-spacing) * 2.5);block-size:calc(var(--raqm-spacing) * 2.5);border-radius:2px;background-color:var(--raqm-foreground);pointer-events:none;z-index:50}.raqm-tooltip-content[data-raqm-side=top] .raqm-tooltip-arrow{bottom:calc(var(--raqm-spacing) * -2.5);left:var(--raqm-tooltip-arrow-offset, 50%);translate:-50% calc(-50% - 2px);rotate:45deg}.raqm-tooltip-content[data-raqm-side=bottom] .raqm-tooltip-arrow{top:var(--raqm-spacing);left:var(--raqm-tooltip-arrow-offset, 50%);translate:-50% calc(-50% - 2px);rotate:45deg}.raqm-tooltip-content[data-raqm-side=left] .raqm-tooltip-arrow{right:calc(var(--raqm-spacing) * -1);top:var(--raqm-tooltip-arrow-offset, 50%);translate:0 -50%;rotate:45deg}.raqm-tooltip-content[data-raqm-side=right] .raqm-tooltip-arrow{left:calc(var(--raqm-spacing) * -1);top:var(--raqm-tooltip-arrow-offset, 50%);translate:0 -50%;rotate:45deg}.raqm-tooltip-content--entering{animation:raqm-tooltip-in var(--raqm-duration-base) ease}.raqm-tooltip-content[data-raqm-side=bottom]{--raqm-tooltip-enter-translate: translateY(-8px)}.raqm-tooltip-content[data-raqm-side=top]{--raqm-tooltip-enter-translate: translateY(8px)}.raqm-tooltip-content[data-raqm-side=left]{--raqm-tooltip-enter-translate: translateX(8px)}.raqm-tooltip-content[data-raqm-side=right]{--raqm-tooltip-enter-translate: translateX(-8px)}@keyframes raqm-tooltip-in{0%{opacity:0;transform:var(--raqm-tooltip-enter-translate, none) scale(.95)}to{opacity:1;transform:none}}.raqm-tooltip-content--closing{opacity:0;transform:scale(.95);transition:opacity var(--raqm-duration-base) ease,transform var(--raqm-duration-base) ease}@media(prefers-reduced-motion:reduce){.raqm-tooltip-content,.raqm-tooltip-content--closing{animation:none;transition:none}}@media(forced-colors:active){.raqm-tooltip-content{border:1px solid CanvasText;background-color:CanvasText;color:Canvas}.raqm-tooltip-arrow{background-color:CanvasText}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		panelTemplate: [{
+			type: i0.ViewChild,
+			args: ["panel", {
+				read: TemplateRef,
+				isSignal: true
+			}]
+		}],
+		disabled: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "disabled",
+				required: false
+			}]
+		}],
+		side: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "side",
+				required: false
+			}]
+		}],
+		align: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "align",
+				required: false
+			}]
+		}],
+		sideOffset: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "sideOffset",
+				required: false
+			}]
+		}],
+		alignOffset: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "alignOffset",
+				required: false
+			}]
+		}],
+		dir: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "dir",
+				required: false
+			}]
+		}]
+	}
+});
+function toDelay(value) {
+	const parsed = numberAttribute(value, 0);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+var RaqmTooltipProviderDirective = class RaqmTooltipProviderDirective {
+	delay = input(0, {
+		...ngDevMode ? { debugName: "delay" } : /* istanbul ignore next */ {},
+		transform: toDelay
+	});
+	active = null;
+	registerActive(active) {
+		if (this.active !== null && this.active !== active) this.active.closeForPeer();
+		this.active = active;
+	}
+	clearActive(active) {
+		if (this.active === active) this.active = null;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RaqmTooltipProviderDirective,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Directive
+	});
+	static ɵdir = i0.ɵɵngDeclareDirective({
+		minVersion: "17.1.0",
+		version: "22.2.2",
+		type: RaqmTooltipProviderDirective,
+		isStandalone: true,
+		selector: "[raqm-tooltip-provider]",
+		inputs: { delay: {
+			classPropertyName: "delay",
+			publicName: "delay",
+			isSignal: true,
+			isRequired: false,
+			transformFunction: null
+		} },
+		providers: [{
+			provide: RAQM_TOOLTIP_PROVIDER,
+			useExisting: RaqmTooltipProviderDirective
+		}],
+		exportAs: ["raqmTooltipProvider"],
+		ngImport: i0
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: RaqmTooltipProviderDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[raqm-tooltip-provider]",
+			exportAs: "raqmTooltipProvider",
+			providers: [{
+				provide: RAQM_TOOLTIP_PROVIDER,
+				useExisting: RaqmTooltipProviderDirective
+			}]
+		}]
+	}],
+	propDecorators: { delay: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "delay",
+			required: false
+		}]
+	}] }
+});
+var RaqmTooltipTriggerDirective = class RaqmTooltipTriggerDirective {
+	host = inject(ElementRef);
+	tooltip = inject(RAQM_TOOLTIP, { optional: true });
+	renderer = inject(Renderer2);
+	destroyRef = inject(DestroyRef);
+	ownedToken = null;
+	ref = (() => {
+		const self = this;
+		return {
+			get element() {
+				return self.host.nativeElement;
+			},
+			get disabled() {
+				const element = self.host.nativeElement;
+				return element instanceof HTMLButtonElement && element.disabled;
+			}
+		};
+	})();
+	constructor() {
+		effect(() => {
+			const token = this.tooltip?.open() ? this.tooltip.tooltipId() : null;
+			untracked(() => this.syncDescribedBy(token));
+		});
+		const element = this.host.nativeElement;
+		if (element instanceof HTMLButtonElement && !element.hasAttribute("type")) element.setAttribute("type", "button");
+		if (isDevMode() && this.tooltip === null) console.error("[raqm-tooltip-trigger] No parent <raqm-tooltip> found; the trigger cannot show a tooltip.");
+		this.destroyRef.onDestroy(() => {
+			this.tooltip?.unregisterTrigger(this.ref);
+			this.syncDescribedBy(null);
+		});
+	}
+	ngOnInit() {
+		this.tooltip?.registerTrigger(this.ref);
+	}
+	onPointerEnter(event) {
+		if (event.pointerType !== "mouse") return;
+		this.tooltip?.requestOpen(this.ref, "mouse");
+	}
+	onPointerLeave(event) {
+		if (event.pointerType !== "mouse") return;
+		this.tooltip?.requestClose(this.ref, "mouse");
+	}
+	onPointerDown(event) {
+		if (event.button !== 0) return;
+		this.tooltip?.requestClose(this.ref, "press");
+	}
+	onFocus() {
+		this.tooltip?.requestOpen(this.ref, "focus");
+	}
+	onBlur() {
+		this.tooltip?.requestClose(this.ref, "focus");
+	}
+	onKeydown(event) {
+		const key = event;
+		if (key.key !== "Escape" || this.tooltip === null) return;
+		if (this.tooltip.open()) {
+			key.preventDefault();
+			key.stopPropagation();
+		}
+		this.tooltip.requestClose(this.ref, "escape");
+	}
+	onClick() {
+		if (this.tooltip?.open()) this.tooltip.requestClose(this.ref, "press");
+	}
+	syncDescribedBy(nextToken) {
+		const element = this.host.nativeElement;
+		const previous = this.ownedToken;
+		if (previous === nextToken) return;
+		const tokens = (element.getAttribute("aria-describedby") ?? "").split(/\s+/).filter((token) => token.length > 0 && token !== previous);
+		if (nextToken !== null && !tokens.includes(nextToken)) tokens.push(nextToken);
+		if (tokens.length > 0) this.renderer.setAttribute(element, "aria-describedby", tokens.join(" "));
+		else this.renderer.removeAttribute(element, "aria-describedby");
+		this.ownedToken = nextToken;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RaqmTooltipTriggerDirective,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Directive
+	});
+	static ɵdir = i0.ɵɵngDeclareDirective({
+		minVersion: "14.0.0",
+		version: "22.2.2",
+		type: RaqmTooltipTriggerDirective,
+		isStandalone: true,
+		selector: "button[raqm-tooltip-trigger], span[raqm-tooltip-trigger]",
+		host: {
+			listeners: {
+				"pointerenter": "onPointerEnter($event)",
+				"pointerleave": "onPointerLeave($event)",
+				"pointerdown": "onPointerDown($event)",
+				"focus": "onFocus()",
+				"blur": "onBlur()",
+				"keydown": "onKeydown($event)",
+				"click": "onClick()"
+			},
+			classAttribute: "raqm-tooltip-trigger"
+		},
+		ngImport: i0
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: RaqmTooltipTriggerDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "button[raqm-tooltip-trigger], span[raqm-tooltip-trigger]",
+			host: {
+				class: "raqm-tooltip-trigger",
+				"(pointerenter)": "onPointerEnter($event)",
+				"(pointerleave)": "onPointerLeave($event)",
+				"(pointerdown)": "onPointerDown($event)",
+				"(focus)": "onFocus()",
+				"(blur)": "onBlur()",
+				"(keydown)": "onKeydown($event)",
+				"(click)": "onClick()"
+			}
+		}]
+	}],
+	ctorParameters: () => []
+});
+var RaqmTooltipContentDirective = class RaqmTooltipContentDirective {
+	template = inject(TemplateRef);
+	tooltip = inject(RAQM_TOOLTIP, { optional: true });
+	destroyRef = inject(DestroyRef);
+	constructor() {
+		if (isDevMode() && this.tooltip === null) console.error("[raqm-tooltip-content] No parent <raqm-tooltip> found; the content is never rendered.");
+		this.destroyRef.onDestroy(() => this.tooltip?.unregisterContent(this.template));
+	}
+	ngOnInit() {
+		this.tooltip?.registerContent(this.template);
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RaqmTooltipContentDirective,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Directive
+	});
+	static ɵdir = i0.ɵɵngDeclareDirective({
+		minVersion: "14.0.0",
+		version: "22.2.2",
+		type: RaqmTooltipContentDirective,
+		isStandalone: true,
+		selector: "ng-template[raqm-tooltip-content]",
+		exportAs: ["raqmTooltipContent"],
+		ngImport: i0
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: RaqmTooltipContentDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "ng-template[raqm-tooltip-content]",
+			exportAs: "raqmTooltipContent"
+		}]
+	}],
+	ctorParameters: () => []
+});
+const RaqmTooltip = [
+	RaqmTooltipComponent,
+	RaqmTooltipContentDirective,
+	RaqmTooltipProviderDirective,
+	RaqmTooltipTriggerDirective
+];
+export { RaqmTooltip, RaqmTooltipComponent, RaqmTooltipContentDirective, RaqmTooltipProviderDirective, RaqmTooltipTriggerDirective };
+
+//# sourceMappingURL=raqm-ui-tooltip.mjs.map