birdclaw 0.8.3 → 0.8.4

package/dist/server/assets/ProfilePreview-C6gAor_j.js

@@ -0,0 +1,752 @@
+import { Bt as profilePreviewTriggerClass, Ft as profilePreviewClass, It as profilePreviewHandleClass, Lt as profilePreviewHeaderClass, Nt as profilePreviewBioClass, Pt as profilePreviewCardClass, Rt as profilePreviewMetaClass, hn as tweetLinkClass, m as cx, zt as profilePreviewNameClass } from "./ui-qbmcMSSX.js";
+import { n as avatarPath, r as formatCompactNumber, t as AvatarChip } from "./AvatarChip-zUDAEmjL.js";
+import { Fragment, useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/lib/tweet-render.ts
+var RAW_URL_PATTERN = /https?:\/\/[^\s<>"'`]+/g;
+var TRAILING_URL_PUNCTUATION = /[),.;:!?]+$/;
+function displayUrlForLink(url) {
+	try {
+		const parsed = new URL(url);
+		const host = parsed.hostname.replace(/^www\./, "");
+		const suffix = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+		return suffix === "/" ? host : `${host}${suffix}`;
+	} catch {
+		return url;
+	}
+}
+function comparableUrl(value) {
+	try {
+		const parsed = new URL(value);
+		return `${parsed.protocol}//${parsed.hostname.replace(/^www\./, "")}${parsed.pathname}`;
+	} catch {
+		return value.split("?")[0] ?? value;
+	}
+}
+function isTweetArticleUrlEntity(entry, article) {
+	if (comparableUrl(entry.expandedUrl) === comparableUrl(article.url)) return true;
+	try {
+		const parsed = new URL(entry.expandedUrl);
+		const host = parsed.hostname.replace(/^www\./, "");
+		return (host === "x.com" || host === "twitter.com") && parsed.pathname.startsWith("/i/article/");
+	} catch {
+		return false;
+	}
+}
+function asRecord(value) {
+	return value && typeof value === "object" ? value : {};
+}
+function tweetEntitiesFromXurl(raw) {
+	const entities = asRecord(raw);
+	const rawMentions = Array.isArray(entities.mentions) ? entities.mentions : [];
+	const rawUrls = Array.isArray(entities.urls) ? entities.urls : [];
+	const rawHashtags = Array.isArray(entities.hashtags) ? entities.hashtags : [];
+	const rawArticle = asRecord(entities.article);
+	const articleTitle = String(rawArticle.title ?? "").trim();
+	const articleUrl = String(rawArticle.url ?? "").trim();
+	return {
+		...rawMentions.length ? { mentions: rawMentions.map((mention) => {
+			const value = asRecord(mention);
+			return {
+				username: String(value.username ?? ""),
+				id: typeof value.id === "string" ? String(value.id) : void 0,
+				start: Number(value.start ?? 0),
+				end: Number(value.end ?? 0)
+			};
+		}) } : {},
+		...rawUrls.length ? { urls: rawUrls.map((url) => {
+			const value = asRecord(url);
+			const expandedUrl = String(value.expandedUrl ?? value.expanded_url ?? value.url ?? "");
+			return {
+				url: String(value.url ?? ""),
+				expandedUrl,
+				displayUrl: String(value.displayUrl ?? value.display_url ?? expandedUrl ?? value.url ?? ""),
+				start: Number(value.start ?? 0),
+				end: Number(value.end ?? 0),
+				...typeof value.title === "string" ? { title: value.title } : {},
+				...typeof value.description === "string" || value.description === null ? { description: value.description } : {},
+				...typeof value.imageUrl === "string" ? { imageUrl: value.imageUrl } : typeof value.image_url === "string" ? { imageUrl: value.image_url } : {},
+				...typeof value.siteName === "string" ? { siteName: value.siteName } : typeof value.site_name === "string" ? { siteName: value.site_name } : {}
+			};
+		}) } : {},
+		...rawHashtags.length ? { hashtags: rawHashtags.map((hashtag) => {
+			const value = asRecord(hashtag);
+			return {
+				tag: String(value.tag ?? value.text ?? ""),
+				start: Number(value.start ?? 0),
+				end: Number(value.end ?? 0)
+			};
+		}) } : {},
+		...articleTitle && articleUrl ? { article: {
+			title: articleTitle,
+			url: articleUrl,
+			...typeof (rawArticle.previewText ?? rawArticle.preview_text) === "string" && String(rawArticle.previewText ?? rawArticle.preview_text).trim() ? { previewText: String(rawArticle.previewText ?? rawArticle.preview_text).trim() } : {},
+			...typeof (rawArticle.coverImageUrl ?? rawArticle.cover_image_url) === "string" && String(rawArticle.coverImageUrl ?? rawArticle.cover_image_url).trim() ? { coverImageUrl: String(rawArticle.coverImageUrl ?? rawArticle.cover_image_url).trim() } : {}
+		} } : {}
+	};
+}
+function profileDescriptionEntitiesFromXurl(raw) {
+	return tweetEntitiesFromXurl(asRecord(raw).description);
+}
+function spansOverlap(leftStart, leftEnd, rightStart, rightEnd) {
+	return leftStart < rightEnd && rightStart < leftEnd;
+}
+function stringIndexFromCodePointIndex(text, index) {
+	if (index <= 0) return 0;
+	let stringIndex = 0;
+	let codePointIndex = 0;
+	for (const character of text) {
+		if (codePointIndex >= index) break;
+		stringIndex += character.length;
+		codePointIndex += 1;
+	}
+	return stringIndex;
+}
+function segmentTextMatches(text, segment, start, end) {
+	const slice = text.slice(start, end);
+	if (segment.kind === "mention") return slice.toLowerCase() === `@${segment.username}`.toLowerCase();
+	if (segment.kind === "hashtag") return slice.toLowerCase() === `#${segment.tag}`.toLowerCase();
+	return slice === segment.url;
+}
+function normalizeSegmentTextRange(text, segment) {
+	if (segment.start >= 0 && segment.end > segment.start && segment.end <= text.length && segmentTextMatches(text, segment, segment.start, segment.end)) return segment;
+	const start = stringIndexFromCodePointIndex(text, segment.start);
+	const end = stringIndexFromCodePointIndex(text, segment.end);
+	if (start >= 0 && end > start && end <= text.length && segmentTextMatches(text, segment, start, end)) return {
+		...segment,
+		start,
+		end
+	};
+	return segment;
+}
+function normalizeTweetUrlEntityRangeForText(text, entry) {
+	const normalized = normalizeSegmentTextRange(text, {
+		...entry,
+		kind: "url"
+	});
+	return {
+		start: normalized.start,
+		end: normalized.end
+	};
+}
+function enrichFallbackUrlEntities(text, entities, resolveExpansion) {
+	const enrichedExistingUrls = (entities.urls ?? []).map((entry) => {
+		const expansion = resolveExpansion?.(entry.url);
+		if (!expansion) return entry;
+		const expandedUrl = expansion.expandedUrl || entry.expandedUrl;
+		return {
+			...entry,
+			expandedUrl,
+			displayUrl: expansion.displayUrl || displayUrlForLink(expandedUrl),
+			...expansion.title ? { title: expansion.title } : {},
+			...expansion && "description" in expansion ? { description: expansion.description ?? null } : {},
+			...expansion.imageUrl ? { imageUrl: expansion.imageUrl } : {},
+			...expansion.siteName ? { siteName: expansion.siteName } : {}
+		};
+	});
+	const fallbackUrls = [];
+	for (const match of text.matchAll(RAW_URL_PATTERN)) {
+		const url = match[0].replace(TRAILING_URL_PUNCTUATION, "");
+		const start = match.index ?? 0;
+		const end = start + url.length;
+		if (!url) continue;
+		if (enrichedExistingUrls.some((entry) => spansOverlap(start, end, entry.start, entry.end))) continue;
+		const expansion = resolveExpansion?.(url);
+		const expandedUrl = expansion?.expandedUrl || url;
+		fallbackUrls.push({
+			url,
+			expandedUrl,
+			displayUrl: expansion?.displayUrl || displayUrlForLink(expandedUrl),
+			start,
+			end,
+			...expansion?.title ? { title: expansion.title } : {},
+			...expansion && "description" in expansion ? { description: expansion.description ?? null } : {},
+			...expansion?.imageUrl ? { imageUrl: expansion.imageUrl } : {},
+			...expansion?.siteName ? { siteName: expansion.siteName } : {}
+		});
+	}
+	if (fallbackUrls.length === 0) return {
+		...entities,
+		urls: enrichedExistingUrls
+	};
+	return {
+		...entities,
+		urls: [...enrichedExistingUrls, ...fallbackUrls].sort((left, right) => left.start - right.start)
+	};
+}
+function collectTweetSegments(entities) {
+	return [
+		...entities.mentions?.map((entry) => ({
+			...entry,
+			kind: "mention"
+		})) ?? [],
+		...entities.urls?.map((entry) => ({
+			...entry,
+			kind: "url"
+		})) ?? [],
+		...entities.hashtags?.map((entry) => ({
+			...entry,
+			kind: "hashtag"
+		})) ?? []
+	].sort((left, right) => left.start - right.start);
+}
+function collectTweetSegmentsForText(text, entities) {
+	return collectTweetSegments(entities).map((segment) => normalizeSegmentTextRange(text, segment)).sort((left, right) => left.start - right.start);
+}
+function renderTweetText(text, entities, renderSegment) {
+	const segments = collectTweetSegmentsForText(text, entities);
+	let cursor = 0;
+	let output = "";
+	for (const segment of segments) {
+		if (segment.start < cursor || segment.end <= segment.start || segment.end > text.length) continue;
+		output += text.slice(cursor, segment.start);
+		const fallback = text.slice(segment.start, segment.end);
+		output += renderSegment(segment, fallback);
+		cursor = segment.end;
+	}
+	output += text.slice(cursor);
+	return output;
+}
+function renderTweetPlainText(text, entities) {
+	return renderTweetText(text, entities, (segment, fallback) => {
+		if (segment.kind === "url") return segment.expandedUrl;
+		if (segment.kind === "mention") return `@${segment.username}`;
+		if (segment.kind === "hashtag") return `#${segment.tag}`;
+		return fallback;
+	});
+}
+//#endregion
+//#region src/lib/url-safety.ts
+var PRIVATE_IPV4_RANGES = [
+	["0.0.0.0", 8],
+	["10.0.0.0", 8],
+	["100.64.0.0", 10],
+	["127.0.0.0", 8],
+	["169.254.0.0", 16],
+	["172.16.0.0", 12],
+	["192.0.0.0", 24],
+	["192.0.2.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["198.51.100.0", 24],
+	["203.0.113.0", 24],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
+];
+function ipv4ToNumber(value) {
+	const parts = value.split(".").map((part) => Number(part));
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part))) return null;
+	if (parts.some((part) => part < 0 || part > 255)) return null;
+	return (parts[0] ?? 0) * 256 ** 3 + (parts[1] ?? 0) * 256 ** 2 + (parts[2] ?? 0) * 256 + (parts[3] ?? 0);
+}
+function isIpv4InRange(address, range, prefix) {
+	const addressNumber = ipv4ToNumber(address);
+	const rangeNumber = ipv4ToNumber(range);
+	if (addressNumber === null || rangeNumber === null) return false;
+	const mask = prefix === 0 ? 0 : 4294967295 << 32 - prefix >>> 0;
+	return (addressNumber & mask) === (rangeNumber & mask);
+}
+function isPrivateIpv4(address) {
+	return PRIVATE_IPV4_RANGES.some(([range, prefix]) => isIpv4InRange(address, range, prefix));
+}
+function normalizeIpv6(address) {
+	return address.toLowerCase().replace(/^\[|\]$/g, "");
+}
+function parseIpv6Parts(address) {
+	let normalized = normalizeIpv6(address);
+	if (!normalized.includes(":")) return null;
+	if (normalized.includes(".")) {
+		const lastColon = normalized.lastIndexOf(":");
+		const addressNumber = ipv4ToNumber(normalized.slice(lastColon + 1));
+		if (addressNumber === null) return null;
+		normalized = `${normalized.slice(0, lastColon + 1)}${(addressNumber >>> 16 & 65535).toString(16)}:${(addressNumber & 65535).toString(16)}`;
+	}
+	const halves = normalized.split("::");
+	if (halves.length > 2) return null;
+	const parseGroups = (value) => value === "" ? [] : value.split(":").map((part) => Number.parseInt(part, 16));
+	const left = parseGroups(halves[0] ?? "");
+	const right = halves.length === 2 ? parseGroups(halves[1] ?? "") : [];
+	const missingGroups = 8 - left.length - right.length;
+	if (halves.length === 1 && missingGroups !== 0 || halves.length === 2 && missingGroups < 0 || ![...left, ...right].every((part) => Number.isInteger(part) && part >= 0 && part <= 65535)) return null;
+	return [
+		...left,
+		...Array.from({ length: missingGroups }, () => 0),
+		...right
+	];
+}
+function ipv4FromHexPair(parts) {
+	if (parts.length !== 2) return null;
+	const high = Number.parseInt(parts[0] ?? "", 16);
+	const low = Number.parseInt(parts[1] ?? "", 16);
+	if (![high, low].every((part) => Number.isInteger(part) && part >= 0 && part <= 65535)) return null;
+	return [
+		high >> 8 & 255,
+		high & 255,
+		low >> 8 & 255,
+		low & 255
+	].join(".");
+}
+function ipv4FromIpv6Parts(parts) {
+	const tailIpv4 = () => [
+		parts[6] >> 8 & 255,
+		parts[6] & 255,
+		parts[7] >> 8 & 255,
+		parts[7] & 255
+	].join(".");
+	const hasZeroPrefix = (length) => parts.slice(0, length).every((part) => part === 0);
+	if (hasZeroPrefix(5) && parts[5] === 65535) return tailIpv4();
+	if (hasZeroPrefix(4) && parts[4] === 65535 && parts[5] === 0) return tailIpv4();
+	if (hasZeroPrefix(6)) return tailIpv4();
+	if (parts[0] === 100 && parts[1] === 65435 && parts[2] === 0) return tailIpv4();
+	if (parts[0] === 100 && parts[1] === 65435 && parts[2] === 1) return tailIpv4();
+	if (parts[0] === 8194) return [
+		parts[1] >> 8 & 255,
+		parts[1] & 255,
+		parts[2] >> 8 & 255,
+		parts[2] & 255
+	].join(".");
+	return null;
+}
+function ipv4FromIpv6Suffix(address) {
+	const normalized = normalizeIpv6(address);
+	const parts = parseIpv6Parts(normalized);
+	if (parts) return ipv4FromIpv6Parts(parts);
+	const prefix = [
+		"::ffff:",
+		"64:ff9b::",
+		"64:ff9b:1::",
+		"::"
+	].find((value) => normalized.startsWith(value));
+	if (!prefix) return null;
+	const suffix = normalized.slice(prefix.length);
+	if (ipv4ToNumber(suffix) !== null) return suffix;
+	return ipv4FromHexPair(suffix.split(":"));
+}
+function isPrivateIpv6(address) {
+	const normalized = normalizeIpv6(address);
+	const parts = parseIpv6Parts(normalized);
+	const mappedIpv4 = parts ? ipv4FromIpv6Parts(parts) : ipv4FromIpv6Suffix(normalized);
+	if (mappedIpv4) return isPrivateIpv4(mappedIpv4);
+	if (parts) {
+		const first = parts[0] ?? 0;
+		return parts.every((part) => part === 0) || parts.slice(0, 7).every((part) => part === 0) || (first & 65024) === 64512 || (first & 65472) === 65152 || (first & 65472) === 65216 || (first & 65280) === 65280;
+	}
+	return false;
+}
+function isBlockedAddress(address) {
+	const normalized = address.replace(/^\[|\]$/g, "");
+	if (ipv4ToNumber(normalized) !== null) return isPrivateIpv4(normalized);
+	if (normalized.includes(":")) return isPrivateIpv6(normalized);
+	return false;
+}
+function isLocalHostname(hostname) {
+	const normalized = hostname.toLowerCase().replace(/\.$/, "");
+	return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal") || normalized.endsWith(".test");
+}
+function assertSafePreviewUrl(url) {
+	const parsed = new URL(url);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("Link preview URL must use http or https");
+	if (parsed.username || parsed.password) throw new Error("Link preview URL must not include credentials");
+	if (isLocalHostname(parsed.hostname) || isBlockedAddress(parsed.hostname)) throw new Error("Link preview URL points to a private host");
+	return parsed;
+}
+function safeHttpUrl(value) {
+	if (!value) return null;
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+		return parsed.toString();
+	} catch {
+		return null;
+	}
+}
+var __test__ = {
+	assertSafePreviewUrl,
+	ipv4FromIpv6Suffix,
+	ipv4ToNumber,
+	isBlockedAddress,
+	isIpv4InRange,
+	isPrivateIpv6,
+	parseIpv6Parts,
+	safeHttpUrl
+};
+//#endregion
+//#region src/components/AvatarPreload.ts
+var MAX_CONCURRENT_PRELOADS = 4;
+var IDLE_TIMEOUT_MS = 2500;
+var PRELOAD_ROOT_MARGIN = "800px 0px";
+var queuedSources = [];
+var knownSources = /* @__PURE__ */ new Set();
+var activeImages = /* @__PURE__ */ new Set();
+var activePreloads = 0;
+var listeningForLoad = false;
+var idleId = null;
+var fallbackTimerId = null;
+function finishPreload(image) {
+	if (!activeImages.delete(image)) return;
+	activePreloads -= 1;
+	drainPreloads();
+}
+function drainPreloads() {
+	while (activePreloads < MAX_CONCURRENT_PRELOADS && queuedSources.length > 0) {
+		const src = queuedSources.shift();
+		if (!src) return;
+		const image = new Image();
+		activePreloads += 1;
+		activeImages.add(image);
+		image.decoding = "async";
+		image.onerror = () => finishPreload(image);
+		image.onload = () => {
+			if (typeof image.decode !== "function") {
+				finishPreload(image);
+				return;
+			}
+			image.decode().catch(() => void 0).finally(() => finishPreload(image));
+		};
+		image.src = src;
+	}
+}
+function runIdlePreloads() {
+	idleId = null;
+	fallbackTimerId = null;
+	drainPreloads();
+}
+function scheduleIdlePreloads() {
+	if (queuedSources.length === 0 || idleId !== null || fallbackTimerId !== null) return;
+	const requestIdle = window.requestIdleCallback?.bind(window);
+	if (requestIdle) {
+		idleId = requestIdle(runIdlePreloads, { timeout: IDLE_TIMEOUT_MS });
+		return;
+	}
+	fallbackTimerId = window.setTimeout(runIdlePreloads, 0);
+}
+function handleWindowLoad() {
+	listeningForLoad = false;
+	scheduleIdlePreloads();
+}
+function scheduleAfterPageLoad() {
+	if (document.readyState === "complete") {
+		scheduleIdlePreloads();
+		return;
+	}
+	if (listeningForLoad) return;
+	listeningForLoad = true;
+	window.addEventListener("load", handleWindowLoad, { once: true });
+}
+function queueAvatarPreload(profileId, avatarUrl) {
+	if (!profileId || !avatarUrl || typeof window === "undefined") return;
+	const src = avatarPath(profileId, avatarUrl);
+	if (knownSources.has(src)) return;
+	knownSources.add(src);
+	queuedSources.push(src);
+	scheduleAfterPageLoad();
+}
+function useAvatarPreload(reference, profileId, avatarUrl) {
+	useEffect(() => {
+		if (!profileId || !avatarUrl) return;
+		const node = reference.current;
+		if (!node || typeof IntersectionObserver === "undefined") {
+			queueAvatarPreload(profileId, avatarUrl);
+			return;
+		}
+		const observer = new IntersectionObserver((entries) => {
+			if (!entries.some((entry) => entry.isIntersecting)) return;
+			observer.disconnect();
+			queueAvatarPreload(profileId, avatarUrl);
+		}, { rootMargin: PRELOAD_ROOT_MARGIN });
+		observer.observe(node);
+		return () => observer.disconnect();
+	}, [
+		avatarUrl,
+		profileId,
+		reference
+	]);
+}
+//#endregion
+//#region src/components/FloatingPreview.tsx
+var DEFAULT_GAP = 10;
+var DEFAULT_GUTTER = 12;
+var DEFAULT_CLOSE_DELAY_MS = 120;
+var initialPosition = {
+	top: 0,
+	left: 0,
+	maxWidth: 0,
+	maxHeight: 0,
+	side: "bottom",
+	measured: false,
+	ready: false
+};
+function edgeRect(rects, side) {
+	return rects.reduce((best, rect) => {
+		if (side === "bottom") {
+			if (rect.bottom > best.bottom) return rect;
+			if (rect.bottom === best.bottom && rect.width > best.width) return rect;
+			return best;
+		}
+		if (rect.top < best.top) return rect;
+		if (rect.top === best.top && rect.width > best.width) return rect;
+		return best;
+	});
+}
+function clamp(value, minimum, maximum) {
+	if (maximum < minimum) return minimum;
+	return Math.min(Math.max(value, minimum), maximum);
+}
+function calculatePreviewPosition({ referenceRects, floatingWidth, floatingHeight, viewport, gap = DEFAULT_GAP, gutter = DEFAULT_GUTTER }) {
+	const referenceTop = Math.min(...referenceRects.map((rect) => rect.top));
+	const referenceBottom = Math.max(...referenceRects.map((rect) => rect.bottom));
+	const availableBelow = Math.max(0, viewport.bottom - gutter - referenceBottom - gap);
+	const availableAbove = Math.max(0, referenceTop - viewport.top - gutter - gap);
+	const side = availableBelow >= floatingHeight || availableBelow >= availableAbove ? "bottom" : "top";
+	const availableHeight = side === "bottom" ? availableBelow : availableAbove;
+	const renderedHeight = Math.min(floatingHeight, availableHeight);
+	const anchor = edgeRect(referenceRects, side);
+	const maxWidth = Math.max(0, viewport.width - gutter * 2);
+	const renderedWidth = Math.min(floatingWidth, maxWidth);
+	const minimumLeft = viewport.left + gutter;
+	const maximumLeft = viewport.right - gutter - renderedWidth;
+	const left = clamp(anchor.left + anchor.width / 2 - renderedWidth / 2, minimumLeft, maximumLeft);
+	return {
+		top: side === "bottom" ? referenceBottom + gap : referenceTop - gap - renderedHeight,
+		left,
+		maxWidth,
+		maxHeight: availableHeight,
+		side,
+		measured: true,
+		ready: true
+	};
+}
+function viewportRect() {
+	const viewport = window.visualViewport;
+	const left = viewport?.offsetLeft ?? 0;
+	const top = viewport?.offsetTop ?? 0;
+	const width = viewport?.width ?? window.innerWidth;
+	const height = viewport?.height ?? window.innerHeight;
+	return {
+		top,
+		right: left + width,
+		bottom: top + height,
+		left,
+		width,
+		height
+	};
+}
+function elementRects(element) {
+	const fragments = Array.from(element.getClientRects()).filter((rect) => rect.width > 0 || rect.height > 0);
+	return fragments.length > 0 ? fragments : [element.getBoundingClientRect()];
+}
+function referenceIntersectsViewport(rects, viewport) {
+	return rects.some((rect) => rect.right >= viewport.left && rect.left <= viewport.right && rect.bottom >= viewport.top && rect.top <= viewport.bottom);
+}
+function samePosition(left, right) {
+	return left.top === right.top && left.left === right.left && left.maxWidth === right.maxWidth && left.maxHeight === right.maxHeight && left.side === right.side && left.measured === right.measured && left.ready === right.ready;
+}
+function floatingStyle(position) {
+	return {
+		position: "fixed",
+		top: position.top,
+		left: position.left,
+		maxWidth: position.measured ? position.maxWidth : void 0,
+		maxHeight: position.measured ? position.maxHeight : void 0,
+		visibility: position.ready ? "visible" : "hidden"
+	};
+}
+function containsTarget(target, ...elements) {
+	return target instanceof Node && elements.some((element) => element?.contains(target));
+}
+function useFloatingPreview(options = {}) {
+	const closeDelayMs = options.closeDelayMs ?? DEFAULT_CLOSE_DELAY_MS;
+	const [open, setOpen] = useState(false);
+	const [position, setPosition] = useState(initialPosition);
+	const floatingId = useId();
+	const referenceRef = useRef(null);
+	const floatingRef = useRef(null);
+	const closeTimerRef = useRef(null);
+	const clearCloseTimer = useCallback(() => {
+		if (closeTimerRef.current === null) return;
+		window.clearTimeout(closeTimerRef.current);
+		closeTimerRef.current = null;
+	}, []);
+	const openPreview = useCallback(() => {
+		clearCloseTimer();
+		if (!open) setPosition(initialPosition);
+		setOpen(true);
+	}, [clearCloseTimer, open]);
+	const closePreview = useCallback(() => {
+		clearCloseTimer();
+		setOpen(false);
+	}, [clearCloseTimer]);
+	const scheduleClose = useCallback(() => {
+		clearCloseTimer();
+		closeTimerRef.current = window.setTimeout(() => {
+			closeTimerRef.current = null;
+			const reference = referenceRef.current;
+			const floating = floatingRef.current;
+			const focusInside = containsTarget(document.activeElement, reference, floating);
+			const pointerInside = Boolean(reference?.matches(":hover")) || Boolean(floating?.matches(":hover"));
+			if (!focusInside && !pointerInside) setOpen(false);
+		}, closeDelayMs);
+	}, [clearCloseTimer, closeDelayMs]);
+	const handleBlur = useCallback((event) => {
+		if (containsTarget(event.relatedTarget, referenceRef.current, floatingRef.current)) return;
+		scheduleClose();
+	}, [scheduleClose]);
+	const handleKeyDown = useCallback((event) => {
+		if (event.key !== "Escape") return;
+		closePreview();
+		referenceRef.current?.querySelector("a,button")?.focus();
+	}, [closePreview]);
+	const updatePlacement = useCallback(() => {
+		const reference = referenceRef.current;
+		const floating = floatingRef.current;
+		if (!reference || !floating) return;
+		const viewport = viewportRect();
+		const referenceRects = elementRects(reference);
+		if (!referenceIntersectsViewport(referenceRects, viewport)) {
+			setPosition((current) => current.ready ? {
+				...current,
+				ready: false
+			} : current);
+			return;
+		}
+		const floatingRect = floating.getBoundingClientRect();
+		const content = floating.querySelector("[data-floating-preview-content]");
+		const style = window.getComputedStyle(floating);
+		const verticalChrome = [
+			style.paddingTop,
+			style.paddingBottom,
+			style.borderTopWidth,
+			style.borderBottomWidth
+		].reduce((total, value) => total + (Number.parseFloat(value) || 0), 0);
+		const naturalHeight = Math.max(floatingRect.height, (content?.getBoundingClientRect().height ?? 0) + verticalChrome);
+		const next = calculatePreviewPosition({
+			referenceRects,
+			floatingWidth: floatingRect.width,
+			floatingHeight: naturalHeight,
+			viewport
+		});
+		if (floatingRect.width > next.maxWidth + .5) next.ready = false;
+		setPosition((current) => samePosition(current, next) ? current : next);
+	}, []);
+	useLayoutEffect(() => {
+		if (!open) return;
+		updatePlacement();
+		let frame = 0;
+		const trackLayout = () => {
+			updatePlacement();
+			frame = window.requestAnimationFrame(trackLayout);
+		};
+		frame = window.requestAnimationFrame(trackLayout);
+		const viewport = window.visualViewport;
+		window.addEventListener("resize", updatePlacement);
+		window.addEventListener("scroll", updatePlacement, true);
+		viewport?.addEventListener("resize", updatePlacement);
+		viewport?.addEventListener("scroll", updatePlacement);
+		const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(updatePlacement);
+		if (referenceRef.current) observer?.observe(referenceRef.current);
+		if (floatingRef.current) observer?.observe(floatingRef.current);
+		return () => {
+			window.cancelAnimationFrame(frame);
+			window.removeEventListener("resize", updatePlacement);
+			window.removeEventListener("scroll", updatePlacement, true);
+			viewport?.removeEventListener("resize", updatePlacement);
+			viewport?.removeEventListener("scroll", updatePlacement);
+			observer?.disconnect();
+		};
+	}, [open, updatePlacement]);
+	useEffect(() => () => clearCloseTimer(), [clearCloseTimer]);
+	const interactionProps = {
+		onPointerEnter: (_event) => openPreview(),
+		onPointerLeave: (_event) => scheduleClose(),
+		onFocus: (_event) => openPreview(),
+		onBlur: handleBlur,
+		onKeyDown: handleKeyDown
+	};
+	return {
+		open,
+		referenceRef,
+		floatingRef,
+		floatingStyle: floatingStyle(position),
+		referenceProps: interactionProps,
+		floatingProps: interactionProps,
+		floatingId,
+		closePreview
+	};
+}
+//#endregion
+//#region src/components/ProfilePreview.tsx
+function ProfilePreviewBio({ profile }) {
+	const segments = collectTweetSegmentsForText(profile.bio, profileDescriptionEntitiesFromXurl(profile.entities));
+	let cursor = 0;
+	return /* @__PURE__ */ jsxs("span", {
+		className: profilePreviewBioClass,
+		children: [segments.map((segment, index) => {
+			if (segment.kind !== "url" || segment.start < cursor || segment.end <= segment.start || segment.end > profile.bio.length) return null;
+			const prefix = profile.bio.slice(cursor, segment.start);
+			cursor = segment.end;
+			const href = safeHttpUrl(segment.expandedUrl);
+			return /* @__PURE__ */ jsxs(Fragment, { children: [prefix, href ? /* @__PURE__ */ jsx("a", {
+				className: tweetLinkClass,
+				href,
+				rel: "noreferrer",
+				target: "_blank",
+				children: segment.expandedUrl
+			}) : profile.bio.slice(segment.start, segment.end)] }, `${segment.url}-${String(index)}`);
+		}), profile.bio.slice(cursor)]
+	});
+}
+function ProfilePreview({ profile, children, className = "" }) {
+	const preview = useFloatingPreview();
+	useAvatarPreload(preview.referenceRef, profile.id, profile.avatarUrl);
+	return /* @__PURE__ */ jsxs("span", {
+		ref: preview.referenceRef,
+		className: cx(profilePreviewClass, className),
+		...preview.referenceProps,
+		children: [/* @__PURE__ */ jsx("a", {
+			"aria-controls": preview.open ? preview.floatingId : void 0,
+			"aria-expanded": preview.open,
+			className: profilePreviewTriggerClass,
+			href: `/profiles/${encodeURIComponent(profile.handle)}`,
+			children
+		}), preview.open ? /* @__PURE__ */ jsx("span", {
+			"aria-label": `${profile.displayName} profile preview`,
+			id: preview.floatingId,
+			ref: preview.floatingRef,
+			className: profilePreviewCardClass,
+			role: "group",
+			style: preview.floatingStyle,
+			...preview.floatingProps,
+			children: /* @__PURE__ */ jsxs("span", {
+				className: "grid gap-2",
+				"data-floating-preview-content": true,
+				children: [
+					/* @__PURE__ */ jsxs("span", {
+						className: profilePreviewHeaderClass,
+						children: [/* @__PURE__ */ jsx(AvatarChip, {
+							avatarUrl: profile.avatarUrl,
+							hue: profile.avatarHue,
+							name: profile.displayName,
+							profileId: profile.id
+						}), /* @__PURE__ */ jsxs("span", {
+							className: "flex min-w-0 flex-col",
+							children: [/* @__PURE__ */ jsx("span", {
+								className: profilePreviewNameClass,
+								children: profile.displayName
+							}), /* @__PURE__ */ jsxs("span", {
+								className: profilePreviewHandleClass,
+								children: ["@", profile.handle]
+							})]
+						})]
+					}),
+					profile.bio ? /* @__PURE__ */ jsx(ProfilePreviewBio, { profile }) : null,
+					/* @__PURE__ */ jsxs("span", {
+						className: profilePreviewMetaClass,
+						children: [formatCompactNumber(profile.followersCount), " followers"]
+					})
+				]
+			})
+		}) : null]
+	});
+}
+//#endregion
+export { assertSafePreviewUrl as a, collectTweetSegmentsForText as c, isTweetArticleUrlEntity as d, normalizeTweetUrlEntityRangeForText as f, tweetEntitiesFromXurl as h, __test__ as i, displayUrlForLink as l, renderTweetPlainText as m, useFloatingPreview as n, isBlockedAddress as o, profileDescriptionEntitiesFromXurl as p, useAvatarPreload as r, safeHttpUrl as s, ProfilePreview as t, enrichFallbackUrlEntities as u };