workbench.glass.main.js · part 505

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/out/vs/workbench/workbench.glass.main.js, part 505. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

glass-1rbuhwb glass-1f3ql1c glass-1xvruvi

glass-47corl glass-j49l66

glass-1kjrdcj glass-l1v4ol

glass-78zum5 glass-6s0dn4 glass-1dbef6d glass-h8yej3 glass-uve7l6 glass-1yxiud8 glass-1rgtt3y glass-yab65l glass-dpxx8g glass-1ypdohk glass-jbqb8w glass-1iuyybk glass-18o3ruo glass-972fbf glass-1ejq31n glass-1b4hy2t glass-gfja2r glass-11pwa6s glass-1ws9gjp glass-1qhh985 glass-1sy0etr glass-1tnzt7h glass-yj58a3 glass-1b16gh4 glass-1pjslub glass-1e1y6u3 glass-15406qy glass-7pq1vu glass-6ekqhr glass-1wd3ewq glass-jb2p0i glass-1qlqyl8 glass-1xh6y1q glass-1t35e8 glass-1aazh3f glass-1pd3egz glass-15bjb6t

glass-78zum5 glass-6s0dn4 glass-1dbef6d glass-h8yej3 glass-uve7l6 glass-1yxiud8 glass-1rgtt3y glass-yab65l glass-dpxx8g glass-1ypdohk glass-18o3ruo glass-972fbf glass-1ejq31n glass-1b4hy2t glass-gfja2r glass-11pwa6s glass-1ws9gjp glass-1qhh985 glass-1sy0etr glass-1tnzt7h glass-yj58a3 glass-1b16gh4 glass-1pjslub glass-1e1y6u3 glass-15406qy glass-7pq1vu glass-6ekqhr glass-1wd3ewq glass-jb2p0i glass-1qlqyl8 glass-1xh6y1q glass-1t35e8 glass-1aazh3f glass-1pd3egz glass-15bjb6t glass-i07v4r glass-1iuyybk

glass-1pwdyn5 glass-1vatr1o glass-2lah0s glass-78zum5 glass-6s0dn4 glass-l56j7k

glass-1pwdyn5 glass-1vatr1o glass-19kjcj4 glass-1bl94mz

Search Google for 

glass-11wthnw glass-1wd3ewq glass-uxw1ft glass-6ikm8r glass-10wlt62 glass-lyipyv

glass-y5h43f glass-4b2ntj glass-uxw1ft glass-6ikm8r glass-10wlt62 glass-lyipyv

glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-78zum5 glass-dt5ytf glass-5cdhqx

use strict

glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-78zum5 glass-6s0dn4 glass-1n2onr6 glass-f6zju3 glass-1yxiud8 glass-cnij5n glass-yab65l glass-jbqb8w glass-1iuyybk glass-18o3ruo glass-1e1y6u3 glass-1ed109x glass-6ikm8r glass-10wlt62 glass-uxw1ft glass-lyipyv glass-15406qy glass-g3p6pi glass-6ekqhr glass-jb2p0i glass-1wm8ruf glass-spwq11 glass-14s4slr

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-78zum5 glass-6s0dn4 glass-1f1oiij

glass-764vg1 glass-ead0dg glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-78zum5 glass-6s0dn4

Search or enter URL

glass-h8yej3 glass-f6zju3 glass-196pc8s glass-cnij5n glass-22095l glass-jb2p0i glass-1wm8ruf glass-spwq11 glass-14s4slr

Search or enter URL

glass-10l6tqk glass-13vifvy glass-3m8u43 glass-1ey2m1c glass-u96u03 glass-f6zju3 glass-1yxiud8 glass-cnij5n glass-yab65l glass-47corl glass-6ikm8r glass-10wlt62 glass-78zum5 glass-6s0dn4 glass-uxw1ft glass-jb2p0i glass-1wm8ruf glass-spwq11 glass-14s4slr

glass-lshs6z glass-1sdyfia

glass-4b2ntj glass-byyjgo glass-1sdyfia

glass-10l6tqk glass-13vifvy glass-3m8u43 glass-1ey2m1c glass-u96u03 glass-bfkjp0 glass-1arjqg4 glass-1e826z5 glass-fdsagq glass-6ikm8r glass-10wlt62 glass-lyipyv glass-uxw1ft glass-1wd3ewq glass-47corl glass-78zum5 glass-6s0dn4

glass-78zum5 glass-6s0dn4 glass-6ikm8r glass-10wlt62 glass-euugli glass-19991ni glass-7pq1vu glass-6ekqhr glass-47corl

glass-78zum5 glass-6s0dn4 glass-6ikm8r glass-10wlt62 glass-euugli glass-19991ni glass-7pq1vu glass-6ekqhr glass-47corl glass-g01cxk

glass-4b2ntj glass-byyjgo

glass-1wd3ewq glass-iiclqw

glass-4b2ntj glass-byyjgo glass-6ikm8r glass-10wlt62 glass-lyipyv glass-uxw1ft

glass-4b2ntj glass-byyjgo glass-6ikm8r glass-10wlt62 glass-lyipyv glass-uxw1ft

glass-4b2ntj glass-byyjgo

Search or enter URL

glass-10l6tqk glass-1vknick glass-aow8t4 glass-1kcukb8 glass-1m7fhj7 glass-f1vpex glass-18o3ruo glass-1dcwbjb glass-fo81ep glass-f6zju3 glass-g31tg3 glass-cnij5n glass-43mhey

Exit Responsive Design Mode

Responsive Design Mode

Exit responsive design mode

Enter responsive design mode

use strict

use strict

Last 7 Days

Last 30 Days

Search history or enter a URL

Search or enter URL...

use strict

Cursor Changelog

Cursor Docs

var e=document.getElementById('cursor-scrollbar-override');

var s=document.createElement('style');

s.textContent=${JSON.stringify([`*{scrollbar-width:thin!important;scrollbar-color:${t} transparent!important}`,"::-webkit-scrollbar{width:8px!important;height:8px!important;background:transparent!important}","::-webkit-scrollbar-track{background:transparent!important}",`::-webkit-scrollbar-thumb{background:${t}!important;border-radius:4px!important}`,`::-webkit-scrollbar-thumb:hover{background:${e}!important}`,"::-webkit-scrollbar-corner{background:transparent!important}"].join(""))};

*{scrollbar-width:thin!important;scrollbar-color:${t} transparent!important}

use strict

use strict

use strict

use strict

	// id -> { members: [{ uid, element, fingerprint }] }. A member whose
	// element is gone holds element null and reports a null rect. The host
	// sends the whole set again on every overlay mount, so turning selection
	// off drops it.
	const annotationAnchors = new Map();
	// uid -> where that element was last seen, in page coordinates. Outlives
	// the registry so a pin seen earlier in this document keeps its place
	// across a design mode re-entry.
	const lastSeenPageRects = new Map();
	// annotation id -> uid of the element its badge last sat on, so a stacked
	// badge holds that spot once none of its elements is on screen.
	const lastBadgeUids = new Map();
	// Added nodes might hold a missing member since it last tried to
	// re-resolve. Kept apart from reconcileHasNewCandidates so a missing
	// member never re-arms the grace-window retry timer.
	let anchorsHaveNewCandidates = false;
	let lastSentAnchorsJson = null;
	let lastSentDevicePixelRatio = null;
	// A set is answered even when nothing moved: a remounted overlay starts
	// with an empty store.
	let anchorsAnswerOwed = false;

	function hasAnnotationAnchors() {
		return annotationAnchors.size > 0;
	}

	function clearAnnotationAnchors() {
		annotationAnchors.clear();
		anchorsHaveNewCandidates = false;
		lastSentAnchorsJson = null;
		anchorsAnswerOwed = false;
	}

	function markAnchorsForRetry() {
		anchorsHaveNewCandidates = true;
	}

	// A missing pin re-resolves only when an added subtree could hold its
	// tag, so a page that streams unrelated DOM does not rescan every frame.
	function noteAddedAnchorCandidates(addedNodeLists) {
		if (anchorsHaveNewCandidates || addedNodeLists.length === 0) return;
		const tags = new Set();
		for (const anchor of annotationAnchors.values()) {
			for (const member of anchor.members) {
				if (!member.element && member.fingerprint) {
					tags.add(member.fingerprint.tagName.toLowerCase());
				}
			}
		}
		if (tags.size === 0) return;
		for (const nodes of addedNodeLists) {
			for (const node of nodes) {
				if (node.nodeType !== Node.ELEMENT_NODE) continue;
				for (const tag of tags) {
					if (node.tagName.toLowerCase() === tag || node.getElementsByTagName(tag).length > 0) {
						anchorsHaveNewCandidates = true;
						return;
					}
				}
			}
		}
	}

	function retryMissingAnchors() {
		if (!anchorsHaveNewCandidates) return;
		anchorsHaveNewCandidates = false;
		const members = [];
		for (const anchor of annotationAnchors.values()) members.push(...anchor.members);
		resolveAnchorMembersByFingerprint(members);
	}

	// Adds each pinned element to the uid -> element map the reconcile walks,
	// preferring a connected element over a disconnected one.
	function mergeAnchorTrackedEntries(byUid) {
		for (const anchor of annotationAnchors.values()) {
			for (const member of anchor.members) {
				if (!member.uid || !member.element) continue;
				const existing = byUid.get(member.uid);
				if (!existing || (!existing.isConnected && member.element.isConnected)) {
					byUid.set(member.uid, member.element);
				}
			}
		}
	}

	function rebindAnchorMembers(uid, replacement, fingerprint) {
		for (const anchor of annotationAnchors.values()) {
			for (const member of anchor.members) {
				if (member.uid !== uid) continue;
				member.element = replacement;
				if (fingerprint) member.fingerprint = fingerprint;
			}
		}
	}

	function outlivesDraft(uid) {
		return launchMemberships.has(uid) || annotationAnchorsOwnUid(uid);
	}

	function annotationAnchorsOwnUid(uid) {
		for (const anchor of annotationAnchors.values()) {
			if (anchor.members.some(member => member.uid === uid)) return true;
		}
		return false;
	}

	// The pinned element is really gone. Its badge stays at the last known
	// place, so the member keeps its latest fingerprint to re-resolve later.
	function detachAnnotationAnchorUid(uid) {
		for (const anchor of annotationAnchors.values()) {
			for (const member of anchor.members) {
				if (member.uid !== uid || !member.element) continue;
				member.fingerprint = selectionFingerprints.get(member.element) || member.fingerprint;
				member.element = null;
			}
		}
	}

	function anchorFingerprintOf(item) {
		if (!item || typeof item.tagName !== 'string' || !item.tagName) return null;
		return {
			tagName: item.tagName,
			id: typeof item.id === 'string' ? item.id : '',
			className: typeof item.className === 'string' ? item.className : '',
			innerText: typeof item.innerText === 'string' ? item.innerText : '',
		};
	}

	function findConnectedElementByUid(uid, tagName, trackedByUid) {
		if (!uid) return null;
		const tracked = trackedByUid.get(uid);
		if (tracked && tracked.isConnected) return tracked;
		if (!tagName) return null;
		const candidates = document.getElementsByTagName(tagName);
		for (let i = 0; i < candidates.length; i++) {
			if (cursorElementIdMap.get(candidates[i]) === uid) return candidates[i];
		}
		return null;
	}

	function bindAnnotationMember(member, element) {
		member.element = element;
		captureSelectionFingerprint(element);
		member.fingerprint = selectionFingerprints.get(element) || member.fingerprint;
	}

	// Fingerprint fallback for members their uid no longer names: a reload
	// mints fresh uids, and a detached member waits for its element to come
	// back. Members sharing a uid (two notes on one element) resolve together
	// instead of competing for it, and an element another pin already holds
	// is never a candidate. The element takes the member's uid unless the
	// live selection or a launch group already owns it under another, so a
	// later pick of it reports the uid the host stored for the pin.
	function resolveAnchorMembersByFingerprint(members) {
		const groups = new Map();
		const bound = new Set();
		for (const member of members) {
			if (member.element) {
				bound.add(member.element);
				continue;
			}
			if (!member.fingerprint) continue;
			const key = member.uid || member;
			const group = groups.get(key);
			if (group) group.push(member);
			else groups.set(key, [member]);
		}
		if (groups.size === 0) return;
		const grouped = Array.from(groups.values());
		const resolved = resolveRestoreItems(
			grouped.map(group => group[0].fingerprint),
			el => bound.has(el)
		);
		for (let i = 0; i < grouped.length; i++) {
			const element = resolved[i];
			if (!element) continue;
			const uid = grouped[i][0].uid;
			const currentUid = cursorElementIdMap.get(element);
			if (
				uid &&
				currentUid !== uid &&
				!(currentUid && (ownsSelectionUid(currentUid) || launchMemberships.has(currentUid)))
			) {
				cursorElementIdMap.set(element, uid);
			}
			for (const member of grouped[i]) bindAnnotationMember(member, element);
		}
	}

	function setAnnotationAnchors(rawAnchors) {
		const trackedByUid = new Map(
			trackedSelectionEntries().map(entry => [entry.uid, entry.el])
		);
		const next = new Map();
		// Fresh members, plus kept bound ones so no fresh member takes their
		// elements. Kept members that are still missing wait for an added
		// subtree that could hold them, like between sets.
		const resolving = [];
		for (const raw of rawAnchors.slice(0, ${ASl})) {
			if (
				!raw ||
				typeof raw.id !== 'string' ||
				!raw.id ||
				raw.id.length > ${RAi} ||
				next.has(raw.id)
			) {
				continue;
			}
			const items = Array.isArray(raw.elements)
				? raw.elements.slice(0, ${slt})
				: [];
			const uids = items.map(item => item && typeof item.uid === 'string' ? item.uid : '');
			const existing = annotationAnchors.get(raw.id);
			if (
				existing &&
				existing.members.length === uids.length &&
				existing.members.every((member, i) => member.uid === uids[i])
			) {
				for (const member of existing.members) if (member.element) resolving.push(member);
				next.set(raw.id, existing);
				continue;
			}
			const members = items.map((item, i) => {
				const fingerprint = anchorFingerprintOf(item);
				const member = { uid: uids[i], element: null, fingerprint };
				const element = findConnectedElementByUid(
					uids[i],
					fingerprint ? fingerprint.tagName : '',
					trackedByUid
				);
				if (element) bindAnnotationMember(member, element);
				resolving.push(member);
				return member;
			});
			next.set(raw.id, { members });
		}
		resolveAnchorMembersByFingerprint(resolving);
		annotationAnchors.clear();
		for (const [id, anchor] of next) annotationAnchors.set(id, anchor);
		refreshDomMutationObserver();
		anchorsAnswerOwed = true;
		scheduleGeometryRefresh();
	}

	function anchorRectOf(element) {
		if (!element || !element.isConnected) return null;
		const rect = element.getBoundingClientRect();
		// Both zero: display:none at this breakpoint, not a real box.
		if (rect.width === 0 && rect.height === 0) return null;
		return { top: rect.top, left: rect.left, width: rect.width, height: rect.height };
	}

	// Reads every member's rect and records where each was last seen. Null
	// means there is nothing to send: selection is off, a capture is in
	// progress, or the host already knows the registry is empty.
	function measureAnnotationAnchors() {
		if (!selectionMode || hiddenForScreenshot) return null;
		if (
			annotationAnchors.size === 0 &&
			(lastSentAnchorsJson === null || lastSentAnchorsJson === '[]')
		) {
			return null;
		}
		const anchors = [];
		for (const [id, anchor] of annotationAnchors) {
			const rects = anchor.members.map(member => {
				const rect = anchorRectOf(member.element);
				if (rect && member.uid) {
					lastSeenPageRects.set(member.uid, {
						top: rect.top + window.scrollY,
						left: rect.left + window.scrollX,
						width: rect.width,
						height: rect.height,
					});
				}
				return rect;
			});
			const onScreen = anchor.members[rects.findIndex(rect => rect !== null)];
			if (onScreen && onScreen.uid) lastBadgeUids.set(id, onScreen.uid);
			const badgeUid = lastBadgeUids.get(id);
			const seenMember =
				anchor.members.find(member => member.uid === badgeUid && lastSeenPageRects.has(member.uid)) ||
				anchor.members.find(member => lastSeenPageRects.has(member.uid));
			const last = seenMember ? lastSeenPageRects.get(seenMember.uid) : null;
			anchors.push({
				id,
				rects,
				lastKnownRect: last && {
					top: last.top - window.scrollY,
					left: last.left - window.scrollX,
					width: last.width,
					height: last.height,
				},
			});
		}
		return anchors;
	}

	// The next document's picker only arrives after its load finishes, so the
	// host clears this one's badges when it goes away, at the new document's
	// commit. Sent directly: no frame follows a pagehide.
	window.addEventListener('pagehide', () => {
		if (lastSentAnchorsJson === null || lastSentAnchorsJson === '[]') return;
		clearAnnotationAnchors();
		sendToHost('annotation-anchors', { anchors: [] });
	});

	function sendAnnotationAnchors(anchors) {
		if (!anchors) return;
		const json = JSON.stringify(anchors);
		// A zoom rescales the host's badges while the CSS rects stay put.
		const devicePixelRatio = window.devicePixelRatio;
		if (
			!anchorsAnswerOwed &&
			json === lastSentAnchorsJson &&
			devicePixelRatio === lastSentDevicePixelRatio
		) {
			return;
		}
		anchorsAnswerOwed = false;
		lastSentAnchorsJson = json;
		lastSentDevicePixelRatio = devicePixelRatio;
		sendToHost('annotation-anchors', { anchors });
	}

	function parseRect(value) {
		if (!value || typeof value !== 'object') return null;
		const { top, left, width, height } = value;
		return [top, left, width, height].every(n => typeof n === 'number' && Number.isFinite(n))
			? { top, left, width, height }
			: null;
	}

	// The page-level scroller around an element: the window, or a body that
	// scrolls in its place. Null when a nested container scrolls it, or when
	// it or an ancestor is fixed, since no page scroll moves it. A fixed
	// element under a transformed ancestor does move with the page, but
	// still only gets scrollIntoView. A body's overflow moves to the viewport unless the root sets its own, and
	// then the window scrolls, not the body. The root's own overflow always
	// scrolls the viewport; in quirks mode scrolling the root does nothing.
	function pageScrollerOf(element) {
		for (let el = element; el && el !== document.documentElement; el = el.parentElement) {
			const style = getComputedStyle(el);
			if (style.position === 'fixed') return null;
			if (
				el !== element &&
				/(auto|scroll|overlay)/.test(style.overflowX + style.overflowY) &&
				(el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth)
			) {
				if (el === document.body) {
					const root = getComputedStyle(document.documentElement);
					return root.overflowX === 'visible' && root.overflowY === 'visible' ? window : el;
				}
				return null;
			}
		}
		return window;
	}

	// Centering the anchor does not always show the note: a region sits at an
	// offset from its anchor, which can be the whole document, and an element
	// taller than the viewport would leave the badge on its top edge above it.
	// Center the region or that top edge when the page scrolls it; a nested
	// scroller still gets the anchor scrolled into view.
	function scrollAnnotationIntoView(id, behavior, regionOffset) {
		if (!selectionMode || hiddenForScreenshot) return;
		const anchor = annotationAnchors.get(id);
		if (!anchor) return;
		const member = anchor.members.find(m => m.element && m.element.isConnected);
		if (!member) return;
		const scrollBehavior = behavior === 'smooth' ? 'smooth' : 'instant';
		const rect = member.element.getBoundingClientRect();
		const target = parseRect(regionOffset) || (rect.height > window.innerHeight
			? { top: 0, left: 0, width: rect.width, height: ${BJ} }
			: null);
		const scroller = target ? pageScrollerOf(member.element) : null;
		if (target && scroller) {
			scroller.scrollBy({
				top: rect.top + target.top + target.height / 2 - window.innerHeight / 2,
				left: rect.left + target.left + target.width / 2 - window.innerWidth / 2,
				behavior: scrollBehavior,
			});
		} else {
			member.element.scrollIntoView({ block: 'center', inline: 'nearest', behavior: scrollBehavior });
		}
		sendAnnotationAnchors(measureAnnotationAnchors());
	}

use strict

	const NON_COMPONENT_PREFIXES = ['_', '$', 'Primitive.', 'Slot.'];

	const FRAMEWORK_INTERNAL_NAMES = new Set([
		'Suspense', 'Fragment', 'StrictMode', 'Profiler', 'SuspenseList',
		'InnerLayoutRouter', 'RedirectErrorBoundary', 'RedirectBoundary',
		'HTTPAccessFallbackErrorBoundary', 'HTTPAccessFallbackBoundary',
		'LoadingBoundary', 'ErrorBoundary', 'InnerScrollAndFocusHandler',
		'ScrollAndFocusHandler', 'RenderFromTemplateContext', 'OuterLayoutRouter',
		'DevRootHTTPAccessFallbackBoundary', 'AppDevOverlayErrorBoundary',
		'AppDevOverlay', 'HotReload', 'Router', 'ErrorBoundaryHandler',
		'AppRouter', 'ServerRoot', 'SegmentStateProvider', 'RootErrorBoundary',
		'LoadableComponent', 'MotionDOMComponent', 'SlotClone',
	]);

	const MAX_COMPONENT_STACK_DEPTH = 5;

	function isUserComponentName(name) {
		if (!name || name.length <= 1) return false;
		if (name[0] !== name[0].toUpperCase()) return false;
		if (FRAMEWORK_INTERNAL_NAMES.has(name)) return false;
		if (name.endsWith('Provider') || name.endsWith('Context')) return false;
		for (let i = 0; i < NON_COMPONENT_PREFIXES.length; i++) {
			if (name.startsWith(NON_COMPONENT_PREFIXES[i])) return false;
		}
		return true;
	}

	function extractFiberComponentName(fiber) {
		const typeToCheck = fiber.elementType || fiber.type;
		if (!typeToCheck || typeof typeToCheck === 'string') return null;
		let name = null;
		if (typeof typeToCheck === 'function') {
			name = typeToCheck.displayName || typeToCheck.name || null;
		} else if (typeof typeToCheck === 'object' && typeToCheck.$$typeof) {
			if (typeToCheck.render) {
				name = typeToCheck.render.displayName || typeToCheck.render.name || null;
			} else if (typeToCheck.type) {
				const inner = typeToCheck.type;
				name = (typeof inner === 'function' ? (inner.displayName || inner.name) : null) || null;
			}
		}
		return name;
	}

	function getReactFiber(element) {
		if (!element || typeof element !== 'object') return null;
		try {
			const reactKey = Object.keys(element).find(k =>
				k.startsWith('__reactFiber$') || k.startsWith('__reactInternalInstance$')
			);
			if (!reactKey) return null;
			return element[reactKey] || null;
		} catch { return null; }
	}

	function getReactComponentStack(element) {
		const stack = [];
		try {
			let fiber = getReactFiber(element);
			if (!fiber) return stack;
			while (fiber && stack.length < MAX_COMPONENT_STACK_DEPTH) {
				const name = extractFiberComponentName(fiber);
				if (name && isUserComponentName(name)) {
					stack.push(name);
				}
				fiber = fiber.return;
			}
		} catch {}
		return stack;
	}

	function getVueComponentStack(element) {
		const stack = [];
		try {
			let current = element;
			while (current) {
				const component = Reflect.get(current, '__vueParentComponent');
				if (component && typeof component === 'object') {
					let comp = component;
					while (comp && stack.length < MAX_COMPONENT_STACK_DEPTH) {
						const type = comp.type;
						if (type && typeof type === 'object') {
							const name = type.__name || type.name || null;
							if (name && typeof name === 'string') {
								stack.push(name);
							}
						}
						comp = comp.parent;
					}
					break;
				}
				current = current.parentElement;
			}
		} catch {}
		return stack;
	}

	function getSvelteComponentStack(element) {
		const stack = [];
		try {
			let current = element;
			while (current) {
				const meta = Reflect.get(current, '__svelte_meta');
				if (meta && typeof meta === 'object') {
					let m = meta.parent;
					while (m && typeof m === 'object' && stack.length < MAX_COMPONENT_STACK_DEPTH) {
						if (m.componentTag && typeof m.componentTag === 'string') {
							stack.push(m.componentTag);
						}
						m = m.parent;
					}
					break;
				}
				current = current.parentElement;
			}
		} catch {}
		return stack;
	}

	function detectFrameworkInfo(element) {
		const reactStack = getReactComponentStack(element);
		if (reactStack.length > 0) {
			return { framework: 'react', name: reactStack[0], stack: reactStack };
		}
		const vueStack = getVueComponentStack(element);
		if (vueStack.length > 0) {
			return { framework: 'vue', name: vueStack[0], stack: vueStack };
		}
		const svelteStack = getSvelteComponentStack(element);
		if (svelteStack.length > 0) {
			return { framework: 'svelte', name: svelteStack[0], stack: svelteStack };
		}
		return null;
	}

	let _cachedFwInfoElement = null;
	let _cachedFwInfoResult = null;

	function detectFrameworkInfoCached(element) {
		if (element === _cachedFwInfoElement) {
			return _cachedFwInfoResult;
		}
		const result = detectFrameworkInfo(element);
		_cachedFwInfoElement = element;
		_cachedFwInfoResult = result;
		return result;
	}

	// hasComponentBoundary walks fiber / DOM ancestor chains and runs for
	// several candidate elements on every RAF'd hover tick, so positive
	// results are cached per element (the WeakMap frees entries with their
	// elements). Only true is cached. A true is stable for the node's
	// lifetime, but a false can flip once a framework attaches its
	// internals (SSR hydration reuses server-rendered nodes, and React's
	// selective hydration defers fiber attachment), so caching it would
	// permanently mis-route hover bubbling for that element.
	const componentBoundaryCache = new WeakMap();

	function hasComponentBoundary(element) {
		if (componentBoundaryCache.get(element) === true) return true;
		const result = computeComponentBoundary(element);
		if (result) {
			componentBoundaryCache.set(element, true);
		}
		return result;
	}

	function computeComponentBoundary(element) {
		try {
			let fiber = getReactFiber(element);
			while (fiber) {
				const name = extractFiberComponentName(fiber);
				if (name && isUserComponentName(name)) {
					return true;
				}
				fiber = fiber.return;
			}
		} catch {}
		try {
			let current = element;
			while (current) {
				const component = Reflect.get(current, '__vueParentComponent');
				if (component && typeof component === 'object') {
					let comp = component;
					while (comp) {
						const type = comp.type;
						if (type && typeof type === 'object') {
							const n = type.__name || type.name || null;
							if (n && typeof n === 'string') {
								return true;
							}
						}
						comp = comp.parent;
					}
					break;
				}
				current = current.parentElement;
			}
		} catch {}
		try {
			let current = element;
			while (current) {
				const meta = Reflect.get(current, '__svelte_meta');
				if (meta && typeof meta === 'object') {
					let m = meta.parent;
					while (m && typeof m === 'object') {
						if (m.componentTag && typeof m.componentTag === 'string') {
							return true;
						}
						m = m.parent;
					}
					break;
				}
				current = current.parentElement;
			}
		} catch {}
		return false;
	}

use strict

	const launchMemberships = new Map();
	const launchGroups = new Map();
	const launchDisplacedStacks = new Map();
	let launchPromotionCounter = 0;

	const planLaunchGroupPromotion = ${Kgk.toString()};
	const pickLaunchGroupActivation = ${Ygk.toString()};

	function ensureShimmerStyles() {
		if (document.querySelector('[data-cursor-picker-shimmer-styles="true"]')) return;
		const style = document.createElement('style');
		style.setAttribute('data-cursor-picker-shimmer-styles', 'true');
		style.textContent =
			'@keyframes cursor-picker-shimmer-sweep {' +
			'0% { transform: translateX(-140%); opacity: 0; }' +
			'15% { opacity: 0.72; }' +
			'85% { opacity: 0.72; }' +
			'100% { transform: translateX(240%); opacity: 0; }' +
			'}' +
			'@media (prefers-reduced-motion: reduce) {' +
			'[data-cursor-picker-shimmer="true"] > [data-cursor-picker-shimmer-sweep="true"] {' +
			'animation: none !important; transform: none !important; opacity: 1 !important;' +
			'background: rgba(127,127,127,0.12) !important; width: 100% !important;' +
			'}' +
			'}';
		document.head.appendChild(style);
	}

	function createShimmerBox(groupId, hueIndex) {
		ensureShimmerStyles();
		const color = getHueColor(hueIndex || 0);
		const box = document.createElement('div');
		box.setAttribute('data-cursor-picker-shimmer', 'true');
		box.setAttribute('data-cursor-picker-shimmer-group', groupId);
		box.style.cssText =
			'position:fixed;border:2px solid ' + color.border + ';' +
			'background:rgba(127,127,127,0.06);border-radius:${F2n}px;' +
			'pointer-events:none;z-index:2147483645;display:none;overflow:hidden;';
		const sweep = document.createElement('div');
		sweep.setAttribute('data-cursor-picker-shimmer-sweep', 'true');
		sweep.style.cssText =
			'position:absolute;inset:0 auto 0 0;width:55%;height:100%;' +
			'background:linear-gradient(90deg,transparent,rgba(255,255,255,0.58),transparent);' +
			'transform:translateX(-140%);opacity:0;will-change:transform,opacity;' +
			'animation:cursor-picker-shimmer-sweep 1.8s linear infinite;';
		box.appendChild(sweep);
		document.body.appendChild(box);
		return box;
	}

	function updateShimmerBox(box, element) {
		if (!element.isConnected) return false;
		applyBoxRect(box, element.getBoundingClientRect());
		return true;
	}

	function removeLaunchMembership(uid) {
		const membership = launchMemberships.get(uid);
		if (!membership) return;
		membership.box.remove();
		launchMemberships.delete(uid);
	}

	function restoreLaunchMembership(uid, snapshot) {
		const box = createShimmerBox(snapshot.groupId, snapshot.hueIndex);
		const membership = {
			groupId: snapshot.groupId,
			element: snapshot.element,
			box,
			hueIndex: snapshot.hueIndex,
			promotedAt: snapshot.promotedAt,
		};
		launchMemberships.set(uid, membership);
		if (!updateShimmerBox(box, snapshot.element)) {
			removeLaunchMembership(uid);
		}
	}

	function pushDisplacedMembership(uid, membership) {
		let stack = launchDisplacedStacks.get(uid);
		if (!stack) {
			stack = [];
			launchDisplacedStacks.set(uid, stack);
		}
		stack.push({
			groupId: membership.groupId,
			element: membership.element,
			hueIndex: membership.hueIndex,
			promotedAt: membership.promotedAt,
		});
	}

	function popRestorableDisplacedMembership(uid) {
		const stack = launchDisplacedStacks.get(uid);
		if (!stack) return null;
		while (stack.length > 0) {
			const candidate = stack.pop();
			const group = launchGroups.get(candidate.groupId);
			if (group && group.state !== 'failed' && candidate.element.isConnected) {
				return candidate;
			}
		}
		launchDisplacedStacks.delete(uid);
		return null;
	}

	function promoteSelectionToGroup(groupId, uids) {
		if (typeof groupId !== 'string' || groupId.length === 0 || groupId.length > 64) return;
		if (!Array.isArray(uids)) return;
		const existingGroup = launchGroups.get(groupId);
		if (existingGroup) {
			if (existingGroup.state !== 'failed') return;
			launchGroups.delete(groupId);
		}
		const currentOwners = new Map();
		for (const [uid, membership] of launchMemberships) {
			currentOwners.set(uid, membership.groupId);
		}
		const plan = planLaunchGroupPromotion(
			currentOwners,
			uids.filter(uid => typeof uid === 'string' && uid.length > 0),
			groupId
		);
		const resolved = new Map();
		for (const uid of plan.assign) {
			const prior = launchMemberships.get(uid);
			let element = multiSelectElements.get(uid);
			let hueIndex = multiSelectHueIndices.get(uid);
			if (!element && lastHoveredElement && cursorElementIdMap.get(lastHoveredElement) === uid) {
				element = lastHoveredElement;
				hueIndex = frozenSelectionHueIndex;
			}
			if (!element && prior) {
				element = prior.element;
				hueIndex = prior.hueIndex;
			}
			if (element && element.isConnected) {
				resolved.set(uid, {
					element,
					hueIndex: typeof hueIndex === 'number' ? hueIndex : 0,
				});
			}
		}
		if (resolved.size === 0) return;

		const promotedAt = ++launchPromotionCounter;
		launchGroups.set(groupId, { state: 'pending', promotedAt });
		const evictedUids = new Set(plan.evict.map(eviction => eviction.uid));
		clearAllMultiSelect();
		frozen = false;
		frozenSelectionHueIndex = 0;
		lastHoveredElement = null;
		updateHighlight(null);
		updateHoverPreview(null);
		sendHoveredRect(null);

		for (const [uid, value] of resolved) {
			const prior = launchMemberships.get(uid);
			if (prior && evictedUids.has(uid)) {
				pushDisplacedMembership(uid, prior);
				removeLaunchMembership(uid);
			}
			const box = createShimmerBox(groupId, value.hueIndex);
			launchMemberships.set(uid, {
				groupId,
				element: value.element,
				box,
				hueIndex: value.hueIndex,
				promotedAt,
			});
			updateShimmerBox(box, value.element);
		}
		refreshDomMutationObserver();
	}

	function markLaunchGroupReady(groupId) {
		const group = launchGroups.get(groupId);
		if (group && group.state === 'pending') {
			group.state = 'ready';
		}
	}

	function demoteGroupToSelection(groupId, restoreSelection) {
		const group = launchGroups.get(groupId);
		if (!group || group.state === 'failed') return;
		group.state = 'failed';
		for (const [uid, membership] of Array.from(launchMemberships.entries())) {
			if (membership.groupId !== groupId) continue;
			removeLaunchMembership(uid);
			const displaced = popRestorableDisplacedMembership(uid);
			if (displaced) {
				restoreLaunchMembership(uid, displaced);
				continue;
			}
			if (!restoreSelection || !membership.element.isConnected) continue;
			multiSelectElements.set(uid, membership.element);
			multiSelectHueIndices.set(uid, membership.hueIndex);
			const box = createMultiSelectBox(membership.hueIndex);
			updateMultiSelectBox(box, membership.element);
			multiSelectBoxes.set(uid, box);
		}
		refreshHoverHues();
		refreshDomMutationObserver();
	}

	function refreshLaunchGroupBoxes() {
		// Read all rects before writing any box style; interleaved
		// read/write would force one reflow per shimmer box. Disconnected
		// memberships are hidden, not reaped: reconcileDisconnectedSelections
		// owns disconnect handling and gives them the same fingerprint
		// rebind and grace window as selection picks.
		const updates = [];
		const hidden = [];
		for (const membership of launchMemberships.values()) {
			if (membership.element.isConnected) {
				updates.push([membership.box, membership.element.getBoundingClientRect()]);
			} else {
				hidden.push(membership.box);
			}
		}
		for (const [box, rect] of updates) {
			applyBoxRect(box, rect);
		}
		for (const box of hidden) {
			box.style.display = 'none';
		}
	}

	function hitTestReadyLaunchGroup(x, y) {
		const hits = [];
		for (const membership of launchMemberships.values()) {
			const group = launchGroups.get(membership.groupId);
			if (!group || group.state !== 'ready' || !membership.element.isConnected) continue;
			const rect = membership.element.getBoundingClientRect();
			if (
				x >= rect.left &&
				x <= rect.right &&
				y >= rect.top &&
				y <= rect.bottom
			) {
				hits.push({
					groupId: membership.groupId,
					promotedAt: membership.promotedAt,
				});
			}
		}
		return pickLaunchGroupActivation(hits);
	}

	function clearLaunchGroups() {
		for (const membership of launchMemberships.values()) {
			membership.box.remove();
		}
		launchMemberships.clear();
		launchGroups.clear();
		launchDisplacedStacks.clear();
		document.querySelector('[data-cursor-picker-shimmer-styles="true"]')?.remove();
	}

use strict

use strict

* { cursor: crosshair !important; }