__vite_ssr_exportName__("parseFileUrlHref", () => { try { return parseFileUrlHref } catch {} });
__vite_ssr_exportName__("splitFilePathPosition", () => { try { return splitFilePathPosition } catch {} });
__vite_ssr_exportName__("formatFilePathPosition", () => { try { return formatFilePathPosition } catch {} });
__vite_ssr_exportName__("resolvePathLinkTarget", () => { try { return resolvePathLinkTarget } catch {} });
__vite_ssr_exportName__("buildFileLinkParentSuffixByPath", () => { try { return buildFileLinkParentSuffixByPath } catch {} });
__vite_ssr_exportName__("fileLinkLabel", () => { try { return fileLinkLabel } catch {} });
const __vite_ssr_import_0__ = await __vite_ssr_import__("/@fs/home/ubuntu/wt/pr-24263/packages/shared/src/path.ts", {"importedNames":["fileBasename","isAbsolutePath","isWindowsAbsolutePath","stripSlashPrefixedWindowsDrive"]});

const POSITION_SUFFIX_CAPTURE_PATTERN = /:(\d+)(?::(\d+))?$/;
const POSITION_HASH_PATTERN = /^#L(\d+)(?:C(\d+))?$/i;
/** Keeps paths percent-encoded to avoid double decoding; non-localhost authorities become UNC shares. */
function parseFileUrlHref(href) {
	try {
		const parsed = new URL(href);
		if (parsed.protocol.toLowerCase() !== "file:") return null;
		const uncHostname = parsed.hostname.toLowerCase() === "localhost" ? "" : parsed.hostname;
		const path = uncHostname ? `\\\\${uncHostname}${parsed.pathname.replaceAll("/", "\\")}` : parsed.pathname;
		if (path.length === 0) return null;
		return {
			path: (0,__vite_ssr_import_0__.stripSlashPrefixedWindowsDrive)(path),
			hash: parsed.hash
		};
	} catch {
		return null;
	}
};
function splitFilePathPosition(path, hash = "") {
	const suffixMatch = path.match(POSITION_SUFFIX_CAPTURE_PATTERN);
	const match = suffixMatch ?? hash.match(POSITION_HASH_PATTERN);
	if (!match?.[1]) return { path };
	const line = Number.parseInt(match[1], 10);
	const column = match[2] === undefined ? undefined : Number.parseInt(match[2], 10);
	return {
		path: suffixMatch ? path.slice(0, -suffixMatch[0].length) : path,
		...line > 0 ? { line } : {},
		...column !== undefined && column > 0 ? { column } : {}
	};
};
function formatFilePathPosition(position) {
	if (!position.line) return position.path;
	return `${position.path}:${position.line}${position.column ? `:${position.column}` : ""}`;
};
function isWindowsPathStyle(value) {
	return (0,__vite_ssr_import_0__.isWindowsAbsolutePath)(value) || /[A-Za-z]:\\/.test(value);
}
function joinPath(base, next, separator) {
	const cleanBase = base.replace(/[\\/]+$/, "");
	if (separator === "\\") {
		return `${cleanBase}\\${next.replaceAll("/", "\\")}`;
	};
	return `${cleanBase}/${next.replace(/^\/+/, "")}`;
}
function inferHomeFromCwd(cwd) {
	const posixUser = cwd.match(/^\/Users\/([^/]+)/);
	if (posixUser?.[1]) {
		return `/Users/${posixUser[1]}`;
	};
	const posixHome = cwd.match(/^\/home\/([^/]+)/);
	if (posixHome?.[1]) {
		return `/home/${posixHome[1]}`;
	};
	const windowsUser = cwd.match(/^([A-Za-z]:[\\/]Users[\\/][^\\/]+)/i);
	if (windowsUser?.[1]) {
		return windowsUser[1];
	};
	return undefined;
}
function resolvePathLinkTarget(rawPath, cwd) {
	const position = splitFilePathPosition(rawPath);
	const { path } = position;
	let resolvedPath = path;
	if (path.startsWith("~/") || isWindowsPathStyle(cwd) && path.startsWith("~\\")) {
		const home = inferHomeFromCwd(cwd);
		if (home) {
			const separator = isWindowsPathStyle(home) ? "\\" : "/";
			resolvedPath = joinPath(home, path.slice(2), separator);
		}
	} else if (!(0,__vite_ssr_import_0__.isAbsolutePath)(path)) {
		const separator = isWindowsPathStyle(cwd) ? "\\" : "/";
		resolvedPath = joinPath(cwd, path, separator);
	};
	return formatFilePathPosition({
		...position,
		path: resolvedPath
	});
};
function pathParentSegments(path) {
	const normalized = path.replaceAll("\\", "/");
	const segments = normalized.split("/").filter((segment) => segment.length > 0);
	return segments.slice(0, -1);
}
function buildFileLinkParentSuffixByPath(filePaths) {
	const groups = new Map();
	for (const filePath of filePaths) {
		const normalizedPath = filePath.replaceAll("\\", "/");
		const pathSegments = normalizedPath.split("/").filter((segment) => segment.length > 0);
		const basename = pathSegments[pathSegments.length - 1];
		if (!basename) continue;
		const group = groups.get(basename) ?? new Set();
		group.add(normalizedPath);
		groups.set(basename, group);
	};
	const suffixByPath = new Map();
	for (const group of groups.values()) {
		const uniquePaths = [...group];
		if (uniquePaths.length < 2) continue;
		const parentSegmentsByPath = new Map(uniquePaths.map((filePath) => [filePath, pathParentSegments(filePath)]));
		const minUniqueDepthByPath = new Map();
		for (const filePath of uniquePaths) {
			const segments = parentSegmentsByPath.get(filePath) ?? [];
			let resolvedDepth = segments.length;
			for (let depth = 1; depth <= segments.length; depth += 1) {
				const candidate = segments.slice(-depth).join("/");
				const collision = uniquePaths.some((otherPath) => {
					if (otherPath === filePath) return false;
					const otherSegments = parentSegmentsByPath.get(otherPath) ?? [];
					return otherSegments.slice(-depth).join("/") === candidate;
				});
				if (!collision) {
					resolvedDepth = depth;
					break;
				}
			};
			minUniqueDepthByPath.set(filePath, resolvedDepth);
		};
		for (const filePath of uniquePaths) {
			const segments = parentSegmentsByPath.get(filePath) ?? [];
			if (segments.length === 0) continue;
			const minUniqueDepth = minUniqueDepthByPath.get(filePath) ?? 1;
			const suffixDepth = Math.min(segments.length, Math.max(minUniqueDepth, 2));
			suffixByPath.set(filePath, segments.slice(-suffixDepth).join("/"));
		}
	};
	return suffixByPath;
};
function fileLinkLabel(file, parentSuffixByPath) {
	const suffix = parentSuffixByPath.get(file.path.replaceAll("\\", "/"));
	return [
		(0,__vite_ssr_import_0__.fileBasename)(file.path),
		suffix,
		file.line ? `L${file.line}${file.column ? `:C${file.column}` : ""}` : undefined
	].filter(Boolean).join(" · ");
}
//# sourceMappingSource=vite-generated
//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["fileLinks.ts"],"sourcesContent":["import {\n  fileBasename,\n  isAbsolutePath,\n  isWindowsAbsolutePath,\n  stripSlashPrefixedWindowsDrive,\n} from \"./path.ts\";\n\nconst POSITION_SUFFIX_CAPTURE_PATTERN = /:(\\d+)(?::(\\d+))?$/;\n\nconst POSITION_HASH_PATTERN = /^#L(\\d+)(?:C(\\d+))?$/i;\n\n/** Keeps paths percent-encoded to avoid double decoding; non-localhost authorities become UNC shares. */\nexport function parseFileUrlHref(\n  href: string,\n): { readonly path: string; readonly hash: string } | null {\n  try {\n    const parsed = new URL(href);\n    if (parsed.protocol.toLowerCase() !== \"file:\") return null;\n\n    const uncHostname = parsed.hostname.toLowerCase() === \"localhost\" ? \"\" : parsed.hostname;\n    const path = uncHostname\n      ? `\\\\\\\\${uncHostname}${parsed.pathname.replaceAll(\"/\", \"\\\\\")}`\n      : parsed.pathname;\n    if (path.length === 0) return null;\n    return { path: stripSlashPrefixedWindowsDrive(path), hash: parsed.hash };\n  } catch {\n    return null;\n  }\n}\n\nexport interface FilePathPosition {\n  readonly path: string;\n  readonly line?: number;\n  readonly column?: number;\n}\n\nexport function splitFilePathPosition(path: string, hash = \"\"): FilePathPosition {\n  const suffixMatch = path.match(POSITION_SUFFIX_CAPTURE_PATTERN);\n  const match = suffixMatch ?? hash.match(POSITION_HASH_PATTERN);\n  if (!match?.[1]) return { path };\n\n  const line = Number.parseInt(match[1], 10);\n  const column = match[2] === undefined ? undefined : Number.parseInt(match[2], 10);\n  return {\n    path: suffixMatch ? path.slice(0, -suffixMatch[0].length) : path,\n    ...(line > 0 ? { line } : {}),\n    ...(column !== undefined && column > 0 ? { column } : {}),\n  };\n}\n\nexport function formatFilePathPosition(position: FilePathPosition): string {\n  if (!position.line) return position.path;\n  return `${position.path}:${position.line}${position.column ? `:${position.column}` : \"\"}`;\n}\n\nfunction isWindowsPathStyle(value: string): boolean {\n  return isWindowsAbsolutePath(value) || /[A-Za-z]:\\\\/.test(value);\n}\n\nfunction joinPath(base: string, next: string, separator: \"/\" | \"\\\\\"): string {\n  const cleanBase = base.replace(/[\\\\/]+$/, \"\");\n  if (separator === \"\\\\\") {\n    return `${cleanBase}\\\\${next.replaceAll(\"/\", \"\\\\\")}`;\n  }\n  return `${cleanBase}/${next.replace(/^\\/+/, \"\")}`;\n}\n\nfunction inferHomeFromCwd(cwd: string): string | undefined {\n  const posixUser = cwd.match(/^\\/Users\\/([^/]+)/);\n  if (posixUser?.[1]) {\n    return `/Users/${posixUser[1]}`;\n  }\n\n  const posixHome = cwd.match(/^\\/home\\/([^/]+)/);\n  if (posixHome?.[1]) {\n    return `/home/${posixHome[1]}`;\n  }\n\n  const windowsUser = cwd.match(/^([A-Za-z]:[\\\\/]Users[\\\\/][^\\\\/]+)/i);\n  if (windowsUser?.[1]) {\n    return windowsUser[1];\n  }\n\n  return undefined;\n}\n\nexport function resolvePathLinkTarget(rawPath: string, cwd: string): string {\n  const position = splitFilePathPosition(rawPath);\n  const { path } = position;\n\n  let resolvedPath = path;\n  if (path.startsWith(\"~/\") || (isWindowsPathStyle(cwd) && path.startsWith(\"~\\\\\"))) {\n    const home = inferHomeFromCwd(cwd);\n    if (home) {\n      const separator: \"/\" | \"\\\\\" = isWindowsPathStyle(home) ? \"\\\\\" : \"/\";\n      resolvedPath = joinPath(home, path.slice(2), separator);\n    }\n  } else if (!isAbsolutePath(path)) {\n    const separator: \"/\" | \"\\\\\" = isWindowsPathStyle(cwd) ? \"\\\\\" : \"/\";\n    resolvedPath = joinPath(cwd, path, separator);\n  }\n\n  return formatFilePathPosition({ ...position, path: resolvedPath });\n}\n\nfunction pathParentSegments(path: string): string[] {\n  const normalized = path.replaceAll(\"\\\\\", \"/\");\n  const segments = normalized.split(\"/\").filter((segment) => segment.length > 0);\n  return segments.slice(0, -1);\n}\n\nexport function buildFileLinkParentSuffixByPath(\n  filePaths: ReadonlyArray<string>,\n): Map<string, string> {\n  const groups = new Map<string, Set<string>>();\n  for (const filePath of filePaths) {\n    const normalizedPath = filePath.replaceAll(\"\\\\\", \"/\");\n    const pathSegments = normalizedPath.split(\"/\").filter((segment) => segment.length > 0);\n    const basename = pathSegments[pathSegments.length - 1];\n    if (!basename) continue;\n    const group = groups.get(basename) ?? new Set<string>();\n    group.add(normalizedPath);\n    groups.set(basename, group);\n  }\n\n  const suffixByPath = new Map<string, string>();\n  for (const group of groups.values()) {\n    const uniquePaths = [...group];\n    if (uniquePaths.length < 2) continue;\n\n    const parentSegmentsByPath = new Map(\n      uniquePaths.map((filePath) => [filePath, pathParentSegments(filePath)]),\n    );\n    const minUniqueDepthByPath = new Map<string, number>();\n\n    for (const filePath of uniquePaths) {\n      const segments = parentSegmentsByPath.get(filePath) ?? [];\n      let resolvedDepth = segments.length;\n      for (let depth = 1; depth <= segments.length; depth += 1) {\n        const candidate = segments.slice(-depth).join(\"/\");\n        const collision = uniquePaths.some((otherPath) => {\n          if (otherPath === filePath) return false;\n          const otherSegments = parentSegmentsByPath.get(otherPath) ?? [];\n          return otherSegments.slice(-depth).join(\"/\") === candidate;\n        });\n        if (!collision) {\n          resolvedDepth = depth;\n          break;\n        }\n      }\n      minUniqueDepthByPath.set(filePath, resolvedDepth);\n    }\n\n    for (const filePath of uniquePaths) {\n      const segments = parentSegmentsByPath.get(filePath) ?? [];\n      if (segments.length === 0) continue;\n      const minUniqueDepth = minUniqueDepthByPath.get(filePath) ?? 1;\n      const suffixDepth = Math.min(segments.length, Math.max(minUniqueDepth, 2));\n      suffixByPath.set(filePath, segments.slice(-suffixDepth).join(\"/\"));\n    }\n  }\n\n  return suffixByPath;\n}\n\nexport function fileLinkLabel(\n  file: FilePathPosition,\n  parentSuffixByPath: ReadonlyMap<string, string>,\n): string {\n  const suffix = parentSuffixByPath.get(file.path.replaceAll(\"\\\\\", \"/\"));\n  return [\n    fileBasename(file.path),\n    suffix,\n    file.line ? `L${file.line}${file.column ? `:C${file.column}` : \"\"}` : undefined,\n  ]\n    .filter(Boolean)\n    .join(\" · \");\n}\n"],"file":"/@fs/home/ubuntu/wt/pr-24263/packages/shared/src/fileLinks.ts"}

//# vitestCache=W3siZmlsZSI6IjEiLCJpZCI6IjEiLCJ1cmwiOiIyIiwiaW1wb3J0cyI6IjMiLCJtYXBwaW5ncyI6ZmFsc2UsImRlcHMiOiI0IiwiZHluYW1pY0RlcHMiOiI1Iiwic3RhdGljTW9ja3MiOm51bGx9LCIvaG9tZS91YnVudHUvd3QvcHItMjQyNjMvcGFja2FnZXMvc2hhcmVkL3NyYy9maWxlTGlua3MudHMiLCIvQGZzL2hvbWUvdWJ1bnR1L3d0L3ByLTI0MjYzL3BhY2thZ2VzL3NoYXJlZC9zcmMvZmlsZUxpbmtzLnRzIix7InVybHMiOiI2IiwiaWRzIjoiNyJ9LFsiOCJdLFtdLFsiOCJdLHt9LCIvQGZzL2hvbWUvdWJ1bnR1L3d0L3ByLTI0MjYzL3BhY2thZ2VzL3NoYXJlZC9zcmMvcGF0aC50cyJd