The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { mediaKindFromPath } from "./mediaPreview.ts"; |
| 2 | import { |
| 3 | isNetworkPath, |
| 4 | isWindowsAbsolutePath, |
| 5 | stripSlashPrefixedWindowsDrive, |
| 6 | workspaceRelativeFilePath, |
| 7 | } from "./path.ts"; |
| 8 | import { |
| 9 | type FilePathPosition, |
| 10 | formatFilePathPosition, |
| 11 | parseFileUrlHref, |
| 12 | resolvePathLinkTarget, |
| 13 | splitFilePathPosition, |
| 14 | } from "./fileLinks.ts"; |
| 15 | |
| 16 | const RELATIVE_PATH_PREFIX_PATTERN = /^(~\/|\.{1,2}\/)/; |
| 17 | |
| 18 | // Names may use any script (`線性代數/考試.pdf`) and routing punctuation (`posts.$id.tsx`, |
| 19 | // `(group)/[id]/+page.svelte`, `@scope/pkg`). The final segment is optional so an explicit |
| 20 | // folder link may end in `/` (`patches/`, `docs/My Folder/`). A bare name with no slash still fails. |
| 21 | const RELATIVE_FILE_PATH_PATTERN = |
| 22 | /^(?:[\p{L}\p{M}\p{N}._$+@()[\]-]+(?: +[\p{L}\p{M}\p{N}._$+@()[\]-]+)*\/)+(?:[\p{L}\p{M}\p{N}._$+@()[\]-]+(?: +[\p{L}\p{M}\p{N}._$+@()[\]-]+)*(?::\d+(?::\d+|-\d+)?)?)?$/u; |
| 23 | |
| 24 | // No `@` here: `me@example.com` is an address, not a file. |
| 25 | const RELATIVE_FILE_NAME_PATTERN = |
| 26 | /^[\p{L}\p{M}\p{N}._$+()[\]-]+(?: +[\p{L}\p{M}\p{N}._$+()[\]-]+)*\.[\p{L}\p{M}\p{N}_-]+(?::\d+(?::\d+|-\d+)?)?$/u; |
| 27 | |
| 28 | const EXTERNAL_SCHEME_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):(.*)$/; |
| 29 | |
| 30 | const POSITION_SUFFIX_PATTERN = /:\d+(?::\d+|-\d+)?$/; |
| 31 | |
| 32 | const POSITION_ONLY_PATTERN = /^\d+(?::\d+|-\d+)?$/; |
| 33 | |
| 34 | const INLINE_CODE_WHITESPACE_PATTERN = /\s/; |
| 35 | |
| 36 | // Inline code with spaces is a file only when it is absolute and every word is a plain name: |
| 37 | // `/Users/me/Mobile Documents/a - b.md` is, `/usr/bin/python3 -m venv .venv` (a flag) is not. |
| 38 | // A space only in the last segment reads as a command (`/usr/local/bin/node server.js`), so it |
| 39 | // must sit under a user root, and nothing after a bin folder counts. |
| 40 | const SPACED_ABSOLUTE_PATH_ROOT_PATTERN = /^(?:\/|~\/|[A-Za-z]:[\\/])/; |
| 41 | const SPACED_PATH_BODY_PATTERN = |
| 42 | /^(?:[\p{L}\p{M}\p{N}._$+@()[\]-]+(?: (?!-+\p{L})[\p{L}\p{M}\p{N}._$+@()[\]-]+)*(?:[\\/]|$))+$/u; |
| 43 | |
| 44 | function isSpacedAbsoluteFilePath(text: string): boolean { |
| 45 | const root = SPACED_ABSOLUTE_PATH_ROOT_PATTERN.exec(text)?.[0]; |
| 46 | if (root === undefined) return false; |
| 47 | const body = text.slice(root.length).replace(POSITION_SUFFIX_PATTERN, ""); |
| 48 | if (!SPACED_PATH_BODY_PATTERN.test(body)) return false; |
| 49 | const firstSpace = body.indexOf(" "); |
| 50 | const foldersBeforeSpace = body.slice(0, firstSpace).split(PATH_SEPARATOR_PATTERN).slice(0, -1); |
| 51 | if (foldersBeforeSpace.some((folder) => folder === "bin" || folder === "sbin")) return false; |
| 52 | const spaceInFolder = PATH_SEPARATOR_PATTERN.test(body.slice(firstSpace)); |
| 53 | if (!spaceInFolder && root === "/" && !/^(?:Users|home)[\\/]/.test(body)) return false; |
| 54 | if (PATH_SEPARATOR_PATTERN.test(body.at(-1) ?? "")) return true; |
| 55 | const basename = body.split(PATH_SEPARATOR_PATTERN).at(-1) ?? ""; |
| 56 | return FILE_EXTENSION_PATTERN.test(basename) || EXTENSIONLESS_FILE_NAMES.has(basename); |
| 57 | } |
| 58 | |
| 59 | const PATH_SEPARATOR_PATTERN = /[\\/]/; |
| 60 | // Agents shorten long paths with a `...` or `…` segment, which no file chip can open. |
| 61 | const ELIDED_PATH_SEGMENT_PATTERN = /(?:^|[\\/])(?:\.{3,}|…)(?:[\\/]|$)/; |
| 62 | |
| 63 | const FILE_EXTENSION_PATTERN = /\.[A-Za-z0-9_-]+$/; |
| 64 | const ANY_FILE_EXTENSION_PATTERN = /\.[^./\\]+$/; |
| 65 | const VERSION_SUFFIX_PATTERN = /\d\.\d[^.]*$/; |
| 66 | const NUMERIC_DOTTED_PATTERN = /^\d+(?:\.\d+)+$/; |
| 67 | |
| 68 | const POSIX_FILE_ROOT_PREFIXES = [ |
| 69 | "/Users/", |
| 70 | "/home/", |
| 71 | "/tmp/", |
| 72 | "/var/", |
| 73 | "/etc/", |
| 74 | "/opt/", |
| 75 | "/mnt/", |
| 76 | "/Volumes/", |
| 77 | "/private/", |
| 78 | "/root/", |
| 79 | "/usr/", |
| 80 | "/bin/", |
| 81 | "/sbin/", |
| 82 | "/lib/", |
| 83 | "/lib64/", |
| 84 | "/srv/", |
| 85 | "/dev/", |
| 86 | "/proc/", |
| 87 | "/sys/", |
| 88 | "/run/", |
| 89 | "/boot/", |
| 90 | "/media/", |
| 91 | "/workspace/", |
| 92 | "/workspaces/", |
| 93 | ] as const; |
| 94 | |
| 95 | export const EXTENSIONLESS_FILE_NAMES: ReadonlySet<string> = new Set([ |
| 96 | "Makefile", |
| 97 | "makefile", |
| 98 | "GNUmakefile", |
| 99 | "Dockerfile", |
| 100 | "Containerfile", |
| 101 | "Justfile", |
| 102 | "justfile", |
| 103 | "Rakefile", |
| 104 | "Gemfile", |
| 105 | "Procfile", |
| 106 | "Brewfile", |
| 107 | "Caddyfile", |
| 108 | "Vagrantfile", |
| 109 | "Jenkinsfile", |
| 110 | "Podfile", |
| 111 | "Fastfile", |
| 112 | "BUILD", |
| 113 | "WORKSPACE", |
| 114 | "LICENSE", |
| 115 | "LICENCE", |
| 116 | "COPYING", |
| 117 | "NOTICE", |
| 118 | "AUTHORS", |
| 119 | "CONTRIBUTORS", |
| 120 | "CHANGELOG", |
| 121 | "README", |
| 122 | "CODEOWNERS", |
| 123 | ]); |
| 124 | |
| 125 | const SINGLE_LABEL_HOSTNAMES = new Set(["localhost"]); |
| 126 | |
| 127 | const GENERIC_HOSTNAME_TLDS = new Set([ |
| 128 | "com", |
| 129 | "net", |
| 130 | "org", |
| 131 | "io", |
| 132 | "dev", |
| 133 | "app", |
| 134 | "ai", |
| 135 | "co", |
| 136 | "edu", |
| 137 | "gov", |
| 138 | "mil", |
| 139 | "info", |
| 140 | "biz", |
| 141 | "xyz", |
| 142 | "me", |
| 143 | "tv", |
| 144 | "gg", |
| 145 | "chat", |
| 146 | "cloud", |
| 147 | "site", |
| 148 | "online", |
| 149 | "tech", |
| 150 | "store", |
| 151 | "link", |
| 152 | ]); |
| 153 | |
| 154 | const COUNTRY_HOSTNAME_TLDS = new Set([ |
| 155 | "uk", |
| 156 | "de", |
| 157 | "fr", |
| 158 | "nl", |
| 159 | "se", |
| 160 | "no", |
| 161 | "fi", |
| 162 | "dk", |
| 163 | "pl", |
| 164 | "ch", |
| 165 | "at", |
| 166 | "be", |
| 167 | "es", |
| 168 | "it", |
| 169 | "pt", |
| 170 | "eu", |
| 171 | "us", |
| 172 | "ca", |
| 173 | "au", |
| 174 | "nz", |
| 175 | "jp", |
| 176 | "kr", |
| 177 | "cn", |
| 178 | "br", |
| 179 | "ru", |
| 180 | "mx", |
| 181 | "ie", |
| 182 | "cz", |
| 183 | "tr", |
| 184 | "sg", |
| 185 | "hk", |
| 186 | // C++ sources end in `.cc`, so `allocator.cc:217` names a file, not a host and port. |
| 187 | "cc", |
| 188 | ]); |
| 189 | |
| 190 | function looksLikeHostname(segment: string, hasPosition: boolean): boolean { |
| 191 | if (segment.startsWith(".")) return false; |
| 192 | const lowered = segment.toLowerCase(); |
| 193 | if (SINGLE_LABEL_HOSTNAMES.has(lowered)) return true; |
| 194 | if (NUMERIC_DOTTED_PATTERN.test(segment)) return true; |
| 195 | const labels = lowered.split("."); |
| 196 | const lastLabel = labels.at(-1); |
| 197 | if (labels.length < 2 || lastLabel === undefined) return false; |
| 198 | if (GENERIC_HOSTNAME_TLDS.has(lastLabel)) return true; |
| 199 | return !hasPosition && COUNTRY_HOSTNAME_TLDS.has(lastLabel); |
| 200 | } |
| 201 | |
| 202 | export function inlineCodeFilePathCandidate(codeText: string): string | null { |
| 203 | const trimmed = codeText.trim(); |
| 204 | if (trimmed.length === 0 || trimmed.includes("`")) return null; |
| 205 | if (INLINE_CODE_WHITESPACE_PATTERN.test(trimmed) && !isSpacedAbsoluteFilePath(trimmed)) { |
| 206 | return null; |
| 207 | } |
| 208 | |
| 209 | const candidate = isWindowsAbsolutePath(trimmed) ? trimmed : trimmed.replaceAll("\\", "/"); |
| 210 | const hasPosition = POSITION_SUFFIX_PATTERN.test(candidate); |
| 211 | if (!hasPosition && !PATH_SEPARATOR_PATTERN.test(candidate)) return null; |
| 212 | if (ELIDED_PATH_SEGMENT_PATTERN.test(candidate.replace(POSITION_SUFFIX_PATTERN, ""))) return null; |
| 213 | |
| 214 | const hasExplicitPathShape = |
| 215 | RELATIVE_PATH_PREFIX_PATTERN.test(candidate) || |
| 216 | candidate.startsWith("/") || |
| 217 | isWindowsAbsolutePath(candidate); |
| 218 | if (!hasExplicitPathShape) { |
| 219 | const withoutPosition = candidate.replace(POSITION_SUFFIX_PATTERN, ""); |
| 220 | // Markdown destinations accept `patches/`. Inline code still needs a |
| 221 | // file-shaped final segment, so a trailing slash stays plain code. |
| 222 | if (withoutPosition.endsWith("/")) return null; |
| 223 | const firstSegment = withoutPosition.split("/")[0] ?? withoutPosition; |
| 224 | if (looksLikeHostname(firstSegment, hasPosition)) return null; |
| 225 | const basename = |
| 226 | withoutPosition |
| 227 | .replace(/[/\\]+$/, "") |
| 228 | .split(/[\\/]/) |
| 229 | .at(-1) ?? ""; |
| 230 | if (VERSION_SUFFIX_PATTERN.test(basename)) return null; |
| 231 | if (!FILE_EXTENSION_PATTERN.test(basename)) { |
| 232 | if (!hasPosition) return EXTENSIONLESS_FILE_NAMES.has(basename) ? candidate : null; |
| 233 | // A `:line` suffix alone does not make `I/W217:220` a file reference. |
| 234 | if ( |
| 235 | withoutPosition.includes("/") && |
| 236 | !ANY_FILE_EXTENSION_PATTERN.test(basename) && |
| 237 | !EXTENSIONLESS_FILE_NAMES.has(basename) |
| 238 | ) { |
| 239 | return null; |
| 240 | } |
| 241 | } |
| 242 | } |
| 243 | return candidate; |
| 244 | } |
| 245 | |
| 246 | export function safeDecodeURIComponent(value: string): string { |
| 247 | try { |
| 248 | return decodeURIComponent(value); |
| 249 | } catch { |
| 250 | return value; |
| 251 | } |
| 252 | } |
| 253 | |
| 254 | export function normalizeMarkdownLinkDestination(value: string): string { |
| 255 | const trimmed = value.trim(); |
| 256 | return trimmed.startsWith("<") && trimmed.endsWith(">") ? trimmed.slice(1, -1) : trimmed; |
| 257 | } |
| 258 | |
| 259 | export function splitMarkdownLinkSearchAndHash(value: string): { |
| 260 | readonly path: string; |
| 261 | readonly hash: string; |
| 262 | } { |
| 263 | const hashIndex = value.indexOf("#"); |
| 264 | const pathWithSearch = hashIndex >= 0 ? value.slice(0, hashIndex) : value; |
| 265 | const hash = hashIndex >= 0 ? value.slice(hashIndex) : ""; |
| 266 | const queryIndex = pathWithSearch.indexOf("?"); |
| 267 | return { |
| 268 | path: queryIndex >= 0 ? pathWithSearch.slice(0, queryIndex) : pathWithSearch, |
| 269 | hash, |
| 270 | }; |
| 271 | } |
| 272 | |
| 273 | /** |
| 274 | * The decoded path a markdown destination names on the host, before any workspace resolution, or |
| 275 | * null for a `file:` URL that does not parse. Clients and the guest media route both read it here. |
| 276 | */ |
| 277 | export function markdownDestinationHostPath(source: string): string | null { |
| 278 | if (/^file:/i.test(source)) { |
| 279 | const target = parseFileUrlHref(source); |
| 280 | return target === null |
| 281 | ? null |
| 282 | : stripSlashPrefixedWindowsDrive(safeDecodeURIComponent(target.path)); |
| 283 | } |
| 284 | return stripSlashPrefixedWindowsDrive( |
| 285 | safeDecodeURIComponent(splitMarkdownLinkSearchAndHash(source).path), |
| 286 | ); |
| 287 | } |
| 288 | |
| 289 | const DIRECT_IMAGE_SOURCE_PATTERN = /^(?:https?:|data:|blob:|\/\/)/i; |
| 290 | const URI_SCHEME_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:/; |
| 291 | |
| 292 | export type MarkdownImageSource = |
| 293 | | { readonly _tag: "Direct"; readonly uri: string } |
| 294 | | { readonly _tag: "WorkspaceFile"; readonly path: string; readonly relative?: true } |
| 295 | | { readonly _tag: "Blocked" }; |
| 296 | |
| 297 | function joinWorkspacePath(workspaceRoot: string, relativePath: string): string { |
| 298 | const separator = isWindowsAbsolutePath(workspaceRoot) ? "\\" : "/"; |
| 299 | const root = workspaceRoot.replace(/[\\/]+$/, ""); |
| 300 | const path = relativePath.replace(/[\\/]/g, separator).replace(/^[\\/]+/, ""); |
| 301 | return `${root}${separator}${path}`; |
| 302 | } |
| 303 | |
| 304 | /** Rendering is not a click, so a network path loads only from the project's own share. */ |
| 305 | function hostFileSource( |
| 306 | path: string, |
| 307 | workspaceRoot: string | null | undefined, |
| 308 | ): MarkdownImageSource { |
| 309 | return isNetworkPath(path) && workspaceRelativeFilePath(path, workspaceRoot) === null |
| 310 | ? { _tag: "Blocked" } |
| 311 | : { _tag: "WorkspaceFile", path }; |
| 312 | } |
| 313 | |
| 314 | /** |
| 315 | * Filesystem paths belong to the environment host and must never reach a |
| 316 | * browser or native image component without first becoming a signed asset URL. |
| 317 | */ |
| 318 | export function classifyMarkdownImageSource( |
| 319 | value: string | null | undefined, |
| 320 | workspaceRoot?: string | null, |
| 321 | ): MarkdownImageSource { |
| 322 | if (value === null || value === undefined) return { _tag: "Blocked" }; |
| 323 | |
| 324 | const source = normalizeMarkdownLinkDestination(value); |
| 325 | if (source.length === 0 || source.startsWith("#") || source.startsWith("?")) { |
| 326 | return { _tag: "Blocked" }; |
| 327 | } |
| 328 | if (DIRECT_IMAGE_SOURCE_PATTERN.test(source)) { |
| 329 | return { _tag: "Direct", uri: source }; |
| 330 | } |
| 331 | |
| 332 | const path = markdownDestinationHostPath(source); |
| 333 | if (path === null) return { _tag: "Blocked" }; |
| 334 | if (/^file:/i.test(source)) return hostFileSource(path, workspaceRoot); |
| 335 | if (path.length === 0) return { _tag: "Blocked" }; |
| 336 | if (path.startsWith("/") || isWindowsAbsolutePath(path)) { |
| 337 | return hostFileSource(path, workspaceRoot); |
| 338 | } |
| 339 | if (URI_SCHEME_PATTERN.test(path) || path.startsWith("~/") || path.startsWith("~\\")) { |
| 340 | return { _tag: "Blocked" }; |
| 341 | } |
| 342 | if (!workspaceRoot) return { _tag: "Blocked" }; |
| 343 | |
| 344 | return { _tag: "WorkspaceFile", path: joinWorkspacePath(workspaceRoot, path), relative: true }; |
| 345 | } |
| 346 | |
| 347 | export function shouldRenderMarkdownImageAsFileLink( |
| 348 | source: MarkdownImageSource, |
| 349 | mediaKind: ReturnType<typeof mediaKindFromPath>, |
| 350 | ): boolean { |
| 351 | return source._tag === "WorkspaceFile" && mediaKind === null; |
| 352 | } |
| 353 | |
| 354 | export function isMarkdownFileLinkLabel(label: string, href: string): boolean { |
| 355 | const destination = parseMarkdownFileLink(href); |
| 356 | if (!destination) return false; |
| 357 | const normalize = (path: string) => |
| 358 | path.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, ""); |
| 359 | const labelPosition = splitFilePathPosition(label.trim()); |
| 360 | if ( |
| 361 | (labelPosition.line !== undefined && labelPosition.line !== destination.line) || |
| 362 | (labelPosition.column !== undefined && labelPosition.column !== destination.column) || |
| 363 | (labelPosition.endLine !== undefined && labelPosition.endLine !== destination.endLine) |
| 364 | ) { |
| 365 | return false; |
| 366 | } |
| 367 | let labelPath = normalize(labelPosition.path); |
| 368 | let destinationPath = normalize(destination.path); |
| 369 | if (labelPath.length === 0) return true; |
| 370 | if (isWindowsAbsolutePath(destination.path)) { |
| 371 | labelPath = labelPath.toLowerCase(); |
| 372 | destinationPath = destinationPath.toLowerCase(); |
| 373 | } |
| 374 | return destinationPath === labelPath || destinationPath.endsWith(`/${labelPath}`); |
| 375 | } |
| 376 | |
| 377 | export function isRelativeFilePath(path: string): boolean { |
| 378 | return ( |
| 379 | RELATIVE_PATH_PREFIX_PATTERN.test(path) || |
| 380 | (!path.startsWith("/") && !isWindowsAbsolutePath(path)) |
| 381 | ); |
| 382 | } |
| 383 | |
| 384 | function looksLikePosixFilesystemPath(path: string): boolean { |
| 385 | if (!path.startsWith("/")) return false; |
| 386 | if (POSIX_FILE_ROOT_PREFIXES.some((prefix) => path.startsWith(prefix))) return true; |
| 387 | if (POSITION_SUFFIX_PATTERN.test(path)) return true; |
| 388 | const basename = path.slice(path.lastIndexOf("/") + 1); |
| 389 | return EXTENSIONLESS_FILE_NAMES.has(basename) || FILE_EXTENSION_PATTERN.test(basename); |
| 390 | } |
| 391 | |
| 392 | function looksLikeFilePath(path: string, authoredPath: string): boolean { |
| 393 | if (isWindowsAbsolutePath(path) || RELATIVE_PATH_PREFIX_PATTERN.test(path)) return true; |
| 394 | if (path.startsWith("/")) return looksLikePosixFilesystemPath(authoredPath); |
| 395 | if (EXTENSIONLESS_FILE_NAMES.has(path)) return true; |
| 396 | return RELATIVE_FILE_PATH_PATTERN.test(authoredPath) || RELATIVE_FILE_NAME_PATTERN.test(path); |
| 397 | } |
| 398 | |
| 399 | function hasExternalScheme(path: string): boolean { |
| 400 | if (isWindowsAbsolutePath(path)) return false; |
| 401 | const match = path.match(EXTERNAL_SCHEME_PATTERN); |
| 402 | if (!match) return false; |
| 403 | const rest = match[2] ?? ""; |
| 404 | if (rest.startsWith("//")) return true; |
| 405 | return !POSITION_ONLY_PATTERN.test(rest); |
| 406 | } |
| 407 | |
| 408 | export function parseMarkdownFileLink(href: string): FilePathPosition | null { |
| 409 | const normalized = normalizeMarkdownLinkDestination(href); |
| 410 | if (normalized.length === 0 || normalized.startsWith("#") || normalized.startsWith("//")) { |
| 411 | return null; |
| 412 | } |
| 413 | |
| 414 | const source = |
| 415 | (normalized.toLowerCase().startsWith("file:") ? parseFileUrlHref(normalized) : null) ?? |
| 416 | splitMarkdownLinkSearchAndHash(normalized); |
| 417 | const path = stripSlashPrefixedWindowsDrive(safeDecodeURIComponent(source.path.trim())); |
| 418 | const hash = safeDecodeURIComponent(source.hash.trim()); |
| 419 | if (path.length === 0 || hasExternalScheme(path)) return null; |
| 420 | |
| 421 | const position = parseFilePathLink(path, hash); |
| 422 | // `src\a.ts` is Windows-relative. A link that already parses keeps its spelling, since POSIX |
| 423 | // names may contain `\`; a rooted `\\host` or `\foo` would change root if rewritten. |
| 424 | if (position || /^[\\/]/.test(path) || isWindowsAbsolutePath(path)) return position; |
| 425 | return path.includes("\\") ? parseFilePathLink(path.replaceAll("\\", "/"), hash) : null; |
| 426 | } |
| 427 | |
| 428 | function parseFilePathLink(path: string, hash: string): FilePathPosition | null { |
| 429 | const position = splitFilePathPosition(path, hash); |
| 430 | return !ELIDED_PATH_SEGMENT_PATTERN.test(position.path) && looksLikeFilePath(position.path, path) |
| 431 | ? position |
| 432 | : null; |
| 433 | } |
| 434 | |
| 435 | const FENCED_CODE_SEGMENT_PATTERN = /(```[\s\S]*?(?:```|$))/; |
| 436 | |
| 437 | const INLINE_CODE_SPAN_PATTERN = /`([^`\n]+)`/g; |
| 438 | |
| 439 | export function extractInlineCodeSpans(text: string): string[] { |
| 440 | const spans: string[] = []; |
| 441 | const segments = text.split(FENCED_CODE_SEGMENT_PATTERN); |
| 442 | for (let index = 0; index < segments.length; index += 2) { |
| 443 | for (const match of (segments[index] ?? "").matchAll(INLINE_CODE_SPAN_PATTERN)) { |
| 444 | const span = match[1]?.trim(); |
| 445 | if (span) spans.push(span); |
| 446 | } |
| 447 | } |
| 448 | return spans; |
| 449 | } |
| 450 | |
| 451 | function markdownRunEndFinder(markdown: string, delimiter: RegExp) { |
| 452 | let runStart = -1; |
| 453 | let runEnd = -1; |
| 454 | return (start: number) => { |
| 455 | if (start >= runStart && start <= runEnd) return runEnd; |
| 456 | delimiter.lastIndex = start; |
| 457 | runStart = start; |
| 458 | runEnd = delimiter.exec(markdown)?.index ?? markdown.length; |
| 459 | return runEnd; |
| 460 | }; |
| 461 | } |
| 462 | |
| 463 | function markdownLinkTailScanner(markdown: string) { |
| 464 | const whitespaceEnd = markdownRunEndFinder(markdown, /\S/g); |
| 465 | const titleEnd = markdownRunEndFinder(markdown, /["']/g); |
| 466 | const titleWhitespaceEnd = markdownRunEndFinder(markdown, /\S/g); |
| 467 | return (start: number) => { |
| 468 | const end = whitespaceEnd(start); |
| 469 | if (markdown[end] === ")") return end + 1; |
| 470 | if (end === start || (markdown[end] !== '"' && markdown[end] !== "'")) return null; |
| 471 | const quoteEnd = titleEnd(end + 1); |
| 472 | if (quoteEnd === markdown.length) return null; |
| 473 | const close = titleWhitespaceEnd(quoteEnd + 1); |
| 474 | return markdown[close] === ")" ? close + 1 : null; |
| 475 | }; |
| 476 | } |
| 477 | |
| 478 | // micromark's own nesting limit. It also keeps link scanning linear: a scan only runs past another |
| 479 | // link's opening parenthesis while that parenthesis counts toward this depth. |
| 480 | const MAX_BARE_DESTINATION_PAREN_DEPTH = 32; |
| 481 | |
| 482 | function bareMarkdownLinkDestinationEnd(markdown: string, start: number): number | null { |
| 483 | const delimiter = /[\s()\\]/g; |
| 484 | delimiter.lastIndex = start; |
| 485 | let depth = 0; |
| 486 | while (true) { |
| 487 | const index = delimiter.exec(markdown)?.index ?? markdown.length; |
| 488 | const char = markdown[index]; |
| 489 | if (char === "\\") { |
| 490 | if (/[()\\]/.test(markdown[index + 1] ?? "")) delimiter.lastIndex = index + 2; |
| 491 | } else if (char === "(") { |
| 492 | if (depth === MAX_BARE_DESTINATION_PAREN_DEPTH) return null; |
| 493 | depth += 1; |
| 494 | } else if (char === ")" && depth > 0) { |
| 495 | depth -= 1; |
| 496 | } else { |
| 497 | return depth === 0 ? index : null; |
| 498 | } |
| 499 | } |
| 500 | } |
| 501 | |
| 502 | function markdownLinkDestinationScanner(markdown: string) { |
| 503 | const whitespaceEnd = markdownRunEndFinder(markdown, /\S/g); |
| 504 | const angleEnd = markdownRunEndFinder(markdown, /[>\n]/g); |
| 505 | // Separate caches keep scans moving forward when angle destinations fall back to bare ones. |
| 506 | const angleTail = markdownLinkTailScanner(markdown); |
| 507 | const bareTail = markdownLinkTailScanner(markdown); |
| 508 | return (start: number) => { |
| 509 | if (markdown[start] !== "(") return null; |
| 510 | const hrefStart = whitespaceEnd(start + 1); |
| 511 | if (markdown[hrefStart] === "<") { |
| 512 | const hrefEnd = angleEnd(hrefStart + 1); |
| 513 | if (hrefEnd > hrefStart + 1 && markdown[hrefEnd] === ">") { |
| 514 | const end = angleTail(hrefEnd + 1); |
| 515 | if (end !== null) return { hrefStart: hrefStart + 1, hrefEnd, end }; |
| 516 | } |
| 517 | } |
| 518 | const hrefEnd = bareMarkdownLinkDestinationEnd(markdown, hrefStart); |
| 519 | if (hrefEnd === null || hrefEnd === hrefStart) return null; |
| 520 | const end = bareTail(hrefEnd); |
| 521 | return end === null ? null : { hrefStart, hrefEnd, end }; |
| 522 | }; |
| 523 | } |
| 524 | |
| 525 | // The composer escapes brackets in labels (`[\[id\].tsx](...)`), and `\]` does not close one. |
| 526 | function unescapedLabelEnd(markdown: string, start: number): number { |
| 527 | let end = markdown.indexOf("]", start); |
| 528 | while (end !== -1) { |
| 529 | let backslashes = 0; |
| 530 | while (end - backslashes > start && markdown[end - backslashes - 1] === "\\") backslashes += 1; |
| 531 | if (backslashes % 2 === 0) return end; |
| 532 | end = markdown.indexOf("]", end + 1); |
| 533 | } |
| 534 | return -1; |
| 535 | } |
| 536 | |
| 537 | export function extractMarkdownLinkHrefs(markdown: string): string[] { |
| 538 | const hrefs: string[] = []; |
| 539 | const scanDestination = markdownLinkDestinationScanner(markdown); |
| 540 | let cursor = 0; |
| 541 | while (cursor < markdown.length) { |
| 542 | const labelStart = markdown.indexOf("[", cursor); |
| 543 | if (labelStart === -1) break; |
| 544 | const labelEnd = unescapedLabelEnd(markdown, labelStart + 1); |
| 545 | if (labelEnd === -1) break; |
| 546 | |
| 547 | // Skip a failed label once; nested openings share its closing bracket. |
| 548 | cursor = labelEnd + 1; |
| 549 | const destination = scanDestination(cursor); |
| 550 | if (!destination) continue; |
| 551 | cursor = destination.end; |
| 552 | const href = markdown.slice(destination.hrefStart, destination.hrefEnd).trim(); |
| 553 | if (href) hrefs.push(href); |
| 554 | } |
| 555 | return hrefs; |
| 556 | } |
| 557 | |
| 558 | export function resolveMarkdownFileLinkTarget( |
| 559 | href: string | undefined, |
| 560 | cwd?: string, |
| 561 | baseDir: string | undefined = cwd, |
| 562 | ): string | null { |
| 563 | return resolveMarkdownFileLink(href, cwd, baseDir)?.targetPath ?? null; |
| 564 | } |
| 565 | |
| 566 | /** Resolves the displayed position and the editor target, which opens at the start line. */ |
| 567 | export function resolveMarkdownFileLink( |
| 568 | href: string | undefined, |
| 569 | cwd?: string, |
| 570 | baseDir: string | undefined = cwd, |
| 571 | ): { sourcePath: string; targetPath: string; position: FilePathPosition } | null { |
| 572 | const source = href ? parseMarkdownFileLink(href) : null; |
| 573 | if (!source) return null; |
| 574 | |
| 575 | const targetPath = resolveParsedFileLinkTarget(source, cwd, baseDir); |
| 576 | if (!targetPath) return null; |
| 577 | return { |
| 578 | sourcePath: source.path, |
| 579 | targetPath, |
| 580 | position: { |
| 581 | ...splitFilePathPosition(targetPath), |
| 582 | ...(source.endLine !== undefined ? { endLine: source.endLine } : {}), |
| 583 | }, |
| 584 | }; |
| 585 | } |
| 586 | |
| 587 | function resolveParsedFileLinkTarget( |
| 588 | target: FilePathPosition, |
| 589 | cwd: string | undefined, |
| 590 | baseDir: string | undefined, |
| 591 | ): string | null { |
| 592 | const pathWithPosition = formatFilePathPosition(target); |
| 593 | if (!isRelativeFilePath(pathWithPosition)) { |
| 594 | // Opening a network path makes Windows sign in to its host with the user's |
| 595 | // NTLM credentials, so only the project's own share becomes a file link. |
| 596 | return isNetworkPath(target.path) && workspaceRelativeFilePath(target.path, cwd) === null |
| 597 | ? null |
| 598 | : pathWithPosition; |
| 599 | } |
| 600 | if (!baseDir) return null; |
| 601 | return resolvePathLinkTarget(pathWithPosition, baseDir); |
| 602 | } |
| 603 | |
| 604 | export function isWindowsDrivePathHref(href: string): boolean { |
| 605 | return /^[A-Za-z]:[\\/]/.test(safeDecodeURIComponent(href)); |
| 606 | } |
| 607 | |
| 608 | // Bare prose paths need a filesystem root or a position, so `/api/users.json` stays a route, |
| 609 | // and a file-shaped last segment. |
| 610 | export function absoluteFilePathMatches(text: string): Array<{ index: number; path: string }> { |
| 611 | const paths: Array<{ index: number; path: string }> = []; |
| 612 | for (const match of text.matchAll(/(^|[\s(["'])(\/[^\s<>"'`]+)/g)) { |
| 613 | const source = match[2]!; |
| 614 | let parentheses = 0; |
| 615 | let brackets = 0; |
| 616 | for (const character of source) { |
| 617 | if (character === "(") parentheses += 1; |
| 618 | if (character === ")") parentheses -= 1; |
| 619 | if (character === "[") brackets += 1; |
| 620 | if (character === "]") brackets -= 1; |
| 621 | } |
| 622 | let end = source.length; |
| 623 | while (end > 0) { |
| 624 | const character = source[end - 1]!; |
| 625 | if (character === ")" && parentheses < 0) parentheses += 1; |
| 626 | else if (character === "]" && brackets < 0) brackets += 1; |
| 627 | else if (!".,;!?:".includes(character)) break; |
| 628 | end -= 1; |
| 629 | } |
| 630 | const path = source.slice(0, end); |
| 631 | // Trimming `/tmp/a/....` to `/tmp/a/` would hide its elided segment. |
| 632 | if (path.endsWith("/") && source.startsWith("...", end)) continue; |
| 633 | if ( |
| 634 | !POSIX_FILE_ROOT_PREFIXES.some((prefix) => path.startsWith(prefix)) && |
| 635 | !POSITION_SUFFIX_PATTERN.test(path) |
| 636 | ) |
| 637 | continue; |
| 638 | // Prose ends a path at whitespace, so `/Users/me/Library/Application Support/...` must not link. |
| 639 | const basename = path.slice(path.lastIndexOf("/") + 1); |
| 640 | if ( |
| 641 | !POSITION_SUFFIX_PATTERN.test(path) && |
| 642 | !FILE_EXTENSION_PATTERN.test(basename) && |
| 643 | !EXTENSIONLESS_FILE_NAMES.has(basename) |
| 644 | ) |
| 645 | continue; |
| 646 | if (!parseMarkdownFileLink(path)) continue; |
| 647 | paths.push({ index: match.index + match[1]!.length, path }); |
| 648 | } |
| 649 | return paths; |
| 650 | } |