1import remarkGfm from "remark-gfm";
2import remarkParse from "remark-parse";
3import { unified } from "unified";
4import type { ContentBlock, ExtractedDocument } from "../extract/document";
5import {
6  isDataUri,
7  normalizeContentType,
8  normalizeMediaUrl,
9  resolveExtensionFromContentType,
10  resolveExtensionFromUrl,
11  resolveKindFromExtension,
12} from "./media-utils";
13import type { MediaAsset, MediaReplacement } from "./types";
14 
15const MARKDOWN_LINK_RE =
16  /(!?\[[^\]\n]*\])\((<)?((?:https?:\/\/[^)\s>]+)|(?:data:[^)>\s]+))(>)?\)/g;
17const FRONTMATTER_COVER_RE = /^(coverImage:\s*")((?:https?:\/\/[^"]+)|(?:data:[^"]+))(")/m;
18const RAW_URL_RE = /(?:https?:\/\/[^\s<>"')\]]+|data:[^\s<>"')\]]+)/g;
19 
20interface MarkdownAstNode {
21  type: string;
22  url?: string | null;
23  alt?: string | null;
24  title?: string | null;
25  value?: string | null;
26  children?: MarkdownAstNode[];
27  position?: {
28    start?: { offset?: number | null };
29    end?: { offset?: number | null };
30  };
31}
32 
33interface MarkdownReplacementRange {
34  start: number;
35  end: number;
36  value: string;
37}
38 
39function inferMediaKindFromLabel(label: string, rawUrl: string): "image" | "video" | undefined {
40  if (label.startsWith("![")) {
41    return "image";
42  }
43 
44  const normalizedLabel = label.replace(/[!\[\]]/g, "").trim().toLowerCase();
45  if (/\b(video|animated[_ -]?gif|gif)\b/.test(normalizedLabel)) {
46    return "video";
47  }
48 
49  if (isDataUri(rawUrl)) {
50    const contentType = normalizeContentType(rawUrl.slice(5, rawUrl.indexOf(";")));
51    return contentType.startsWith("image/") ? "image" : contentType.startsWith("video/") ? "video" : undefined;
52  }
53 
54  return resolveKindFromExtension(resolveExtensionFromUrl(rawUrl));
55}
56 
57function inferMediaKindFromRawUrl(rawUrl: string): "image" | "video" | undefined {
58  if (isDataUri(rawUrl)) {
59    const contentType = normalizeContentType(rawUrl.slice(5, rawUrl.indexOf(";")));
60    return contentType.startsWith("image/") ? "image" : contentType.startsWith("video/") ? "video" : undefined;
61  }
62 
63  return resolveKindFromExtension(resolveExtensionFromUrl(rawUrl));
64}
65 
66function pushMedia(assets: MediaAsset[], seen: Set<string>, media: MediaAsset): void {
67  const normalizedUrl = normalizeMediaUrl(media.url);
68  if (!normalizedUrl || seen.has(normalizedUrl)) {
69    return;
70  }
71  seen.add(normalizedUrl);
72  assets.push({
73    ...media,
74    url: normalizedUrl,
75  });
76}
77 
78function getNodeOffsets(node: MarkdownAstNode): { start: number; end: number } | null {
79  const start = node.position?.start?.offset;
80  const end = node.position?.end?.offset;
81  if (typeof start !== "number" || typeof end !== "number" || start < 0 || end < start) {
82    return null;
83  }
84  return { start, end };
85}
86 
87function escapeMarkdownLabel(value: string): string {
88  return value.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
89}
90 
91function escapeMarkdownTitle(value: string): string {
92  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
93}
94 
95function formatMarkdownDestination(url: string): string {
96  return /[\s()<>]/.test(url) ? `<${url}>` : url;
97}
98 
99function serializeImageNode(node: MarkdownAstNode): string {
100  const rawUrl = node.url ?? "";
101  const normalizedUrl = normalizeMediaUrl(rawUrl);
102  const alt = escapeMarkdownLabel(node.alt ?? "");
103  const title = node.title ? ` "${escapeMarkdownTitle(node.title)}"` : "";
104  return `![${alt}](${formatMarkdownDestination(normalizedUrl)}${title})`;
105}
106 
107function serializeLinkedImageNode(linkNode: MarkdownAstNode, imageNode: MarkdownAstNode): string {
108  const imageMarkdown = serializeImageNode(imageNode);
109  const imageUrl = normalizeMediaUrl(imageNode.url ?? "");
110  const linkUrl = normalizeMediaUrl(linkNode.url ?? "");
111 
112  if (!linkUrl || linkUrl === imageUrl) {
113    return imageMarkdown;
114  }
115 
116  const title = linkNode.title ? ` "${escapeMarkdownTitle(linkNode.title)}"` : "";
117  return `[${imageMarkdown}](${formatMarkdownDestination(linkUrl)}${title})`;
118}
119 
120function isParagraphWithSingleText(node: MarkdownAstNode | undefined, expectedValue: string): boolean {
121  if (node?.type !== "paragraph" || node.children?.length !== 1) {
122    return false;
123  }
124 
125  const child = node.children[0];
126  return child?.type === "text" && child.value?.trim() === expectedValue;
127}
128 
129function getSingleImageFromParagraph(node: MarkdownAstNode | undefined): MarkdownAstNode | null {
130  if (node?.type !== "paragraph" || node.children?.length !== 1) {
131    return null;
132  }
133 
134  return node.children[0]?.type === "image" ? node.children[0] : null;
135}
136 
137function extractBrokenLinkedImageDestination(node: MarkdownAstNode | undefined): string | null {
138  if (node?.type !== "paragraph") {
139    return null;
140  }
141 
142  const children = node.children ?? [];
143  if (children.length !== 3) {
144    return null;
145  }
146 
147  const [prefix, linkNode, suffix] = children;
148  if (prefix?.type !== "text" || prefix.value?.trim() !== "](") {
149    return null;
150  }
151  if (linkNode?.type !== "link" || !linkNode.url) {
152    return null;
153  }
154  if (suffix?.type !== "text" || suffix.value?.trim() !== ")") {
155    return null;
156  }
157 
158  return linkNode.url;
159}
160 
161function collectLinkedImageReplacements(
162  node: MarkdownAstNode,
163  replacements: MarkdownReplacementRange[],
164): void {
165  const children = node.children ?? [];
166 
167  if (node.type === "link" && children.length === 1 && children[0]?.type === "image") {
168    const offsets = getNodeOffsets(node);
169    if (offsets) {
170      replacements.push({
171        start: offsets.start,
172        end: offsets.end,
173        value: serializeLinkedImageNode(node, children[0]),
174      });
175    }
176    return;
177  }
178 
179  for (const child of children) {
180    collectLinkedImageReplacements(child, replacements);
181  }
182}
183 
184function collectBrokenLinkedImageReplacements(
185  node: MarkdownAstNode,
186  replacements: MarkdownReplacementRange[],
187): void {
188  const children = node.children ?? [];
189  for (let index = 0; index <= children.length - 3; index += 1) {
190    const openParagraph = children[index];
191    const imageParagraph = children[index + 1];
192    const closeParagraph = children[index + 2];
193 
194    if (!isParagraphWithSingleText(openParagraph, "[")) {
195      continue;
196    }
197 
198    const imageNode = getSingleImageFromParagraph(imageParagraph);
199    if (!imageNode) {
200      continue;
201    }
202 
203    const linkUrl = extractBrokenLinkedImageDestination(closeParagraph);
204    if (!linkUrl) {
205      continue;
206    }
207 
208    const start = openParagraph.position?.start?.offset;
209    const end = closeParagraph.position?.end?.offset;
210    if (typeof start !== "number" || typeof end !== "number" || end < start) {
211      continue;
212    }
213 
214    replacements.push({
215      start,
216      end,
217      value: serializeLinkedImageNode({ type: "link", url: linkUrl }, imageNode),
218    });
219 
220    index += 2;
221  }
222 
223  for (const child of children) {
224    collectBrokenLinkedImageReplacements(child, replacements);
225  }
226}
227 
228function applyReplacements(source: string, replacements: MarkdownReplacementRange[]): string {
229  if (replacements.length === 0) {
230    return source;
231  }
232 
233  let result = source;
234  const sorted = [...replacements].sort((left, right) => right.start - left.start);
235  for (const replacement of sorted) {
236    result = `${result.slice(0, replacement.start)}${replacement.value}${result.slice(replacement.end)}`;
237  }
238  return result;
239}
240 
241function normalizeLinkedImageMarkdown(markdown: string): string {
242  let tree: MarkdownAstNode;
243  try {
244    tree = unified().use(remarkParse).use(remarkGfm).parse(markdown) as MarkdownAstNode;
245  } catch {
246    return markdown;
247  }
248 
249  const replacements: MarkdownReplacementRange[] = [];
250  collectLinkedImageReplacements(tree, replacements);
251  collectBrokenLinkedImageReplacements(tree, replacements);
252  return applyReplacements(markdown, replacements);
253}
254 
255export function normalizeMarkdownMediaLinks(markdown: string): string {
256  MARKDOWN_LINK_RE.lastIndex = 0;
257  let result = markdown.replace(MARKDOWN_LINK_RE, (full, label, openAngle, rawUrl, closeAngle) => {
258    const normalizedUrl = normalizeMediaUrl(rawUrl);
259    if (normalizedUrl === rawUrl) {
260      return full;
261    }
262    return `${label}(${openAngle ?? ""}${normalizedUrl}${closeAngle ?? ""})`;
263  });
264 
265  result = result.replace(FRONTMATTER_COVER_RE, (full, prefix, rawUrl, suffix) => {
266    const normalizedUrl = normalizeMediaUrl(rawUrl);
267    if (normalizedUrl === rawUrl) {
268      return full;
269    }
270    return `${prefix}${normalizedUrl}${suffix}`;
271  });
272 
273  RAW_URL_RE.lastIndex = 0;
274  result = result.replace(RAW_URL_RE, (rawUrl) => normalizeMediaUrl(rawUrl));
275  return normalizeLinkedImageMarkdown(result);
276}
277 
278export function collectMediaFromText(
279  text: string,
280  options: {
281    role?: MediaAsset["role"];
282    defaultKind?: MediaAsset["kind"];
283    seen?: Set<string>;
284    into?: MediaAsset[];
285  } = {},
286): MediaAsset[] {
287  const assets = options.into ?? [];
288  const seen = options.seen ?? new Set<string>();
289 
290  MARKDOWN_LINK_RE.lastIndex = 0;
291  let linkMatch: RegExpExecArray | null;
292  while ((linkMatch = MARKDOWN_LINK_RE.exec(text))) {
293    const label = linkMatch[1] ?? "";
294    const rawUrl = linkMatch[3] ?? "";
295    const kind = inferMediaKindFromLabel(label, rawUrl) ?? options.defaultKind;
296    if (!kind) {
297      continue;
298    }
299    pushMedia(assets, seen, {
300      url: rawUrl,
301      kind,
302      role: options.role ?? "inline",
303    });
304  }
305 
306  RAW_URL_RE.lastIndex = 0;
307  let rawMatch: RegExpExecArray | null;
308  while ((rawMatch = RAW_URL_RE.exec(text))) {
309    const rawUrl = rawMatch[0] ?? "";
310    const kind = inferMediaKindFromRawUrl(rawUrl) ?? options.defaultKind;
311    if (!kind) {
312      continue;
313    }
314    pushMedia(assets, seen, {
315      url: rawUrl,
316      kind,
317      role: options.role ?? "inline",
318    });
319  }
320 
321  return assets;
322}
323 
324function collectMediaFromBlock(
325  block: ContentBlock,
326  assets: MediaAsset[],
327  seen: Set<string>,
328): void {
329  switch (block.type) {
330    case "image":
331      pushMedia(assets, seen, {
332        url: block.url,
333        kind: "image",
334        role: "inline",
335        alt: block.alt,
336      });
337      return;
338    case "html":
339    case "markdown":
340      collectMediaFromText(block.type === "html" ? block.html : block.markdown, {
341        role: "inline",
342        seen,
343        into: assets,
344      });
345      return;
346    case "paragraph":
347    case "quote":
348      collectMediaFromText(block.text, {
349        role: "inline",
350        seen,
351        into: assets,
352      });
353      return;
354    case "list":
355      for (const item of block.items) {
356        collectMediaFromText(item, {
357          role: "attachment",
358          seen,
359          into: assets,
360        });
361      }
362      return;
363    case "heading":
364    case "code":
365      return;
366  }
367}
368 
369export function collectMediaFromDocument(document: ExtractedDocument): MediaAsset[] {
370  const assets: MediaAsset[] = [];
371  const seen = new Set<string>();
372  const coverImage =
373    typeof document.metadata?.coverImage === "string" ? document.metadata.coverImage : undefined;
374 
375  if (coverImage) {
376    pushMedia(assets, seen, {
377      url: coverImage,
378      kind: "image",
379      role: "cover",
380    });
381  }
382 
383  for (const block of document.content) {
384    collectMediaFromBlock(block, assets, seen);
385  }
386 
387  return assets;
388}
389 
390export function collectMediaFromMarkdown(markdown: string): MediaAsset[] {
391  const assets: MediaAsset[] = [];
392  const seen = new Set<string>();
393  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
394  if (fmMatch) {
395    const coverMatch = fmMatch[1]?.match(FRONTMATTER_COVER_RE);
396    if (coverMatch?.[2]) {
397      pushMedia(assets, seen, {
398        url: coverMatch[2],
399        kind: "image",
400        role: "cover",
401      });
402    }
403  }
404 
405  collectMediaFromText(markdown, { seen, into: assets });
406  return assets;
407}
408 
409export function rewriteMarkdownMediaLinks(
410  markdown: string,
411  replacements: MediaReplacement[],
412): string {
413  if (replacements.length === 0) {
414    return markdown;
415  }
416 
417  const replacementMap = new Map<string, string>();
418  for (const item of replacements) {
419    replacementMap.set(item.url, item.localPath);
420    replacementMap.set(normalizeMediaUrl(item.url), item.localPath);
421  }
422 
423  MARKDOWN_LINK_RE.lastIndex = 0;
424  let result = markdown.replace(MARKDOWN_LINK_RE, (full, label, _openAngle, rawUrl) => {
425    const replacement = replacementMap.get(rawUrl) ?? replacementMap.get(normalizeMediaUrl(rawUrl));
426    if (!replacement) {
427      return full;
428    }
429    return `${label}(${replacement})`;
430  });
431 
432  result = result.replace(FRONTMATTER_COVER_RE, (full, prefix, rawUrl, suffix) => {
433    const replacement = replacementMap.get(rawUrl) ?? replacementMap.get(normalizeMediaUrl(rawUrl));
434    if (!replacement) {
435      return full;
436    }
437    return `${prefix}${replacement}${suffix}`;
438  });
439 
440  for (const { url, localPath } of replacements) {
441    result = result.split(url).join(localPath);
442    const normalizedUrl = normalizeMediaUrl(url);
443    if (normalizedUrl !== url) {
444      result = result.split(normalizedUrl).join(localPath);
445    }
446  }
447 
448  return result;
449}
450 
451export function resolveDataUriExtension(rawUrl: string): string | undefined {
452  if (!isDataUri(rawUrl)) {
453    return undefined;
454  }
455  const separatorIndex = rawUrl.indexOf(";");
456  const contentType = normalizeContentType(rawUrl.slice(5, separatorIndex === -1 ? undefined : separatorIndex));
457  return resolveExtensionFromContentType(contentType);
458}
459