@farm.js/core 0.1.24 → 0.1.25

package/dist/{chunk-OFEY6KHO.mjs → chunk-U4MP7XTD.mjs}

@@ -2,6 +2,146 @@ import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
 
+// src/markdown-view.ts
+var FENCE = /^\s{0,3}(`{3,}|~{3,})/;
+var ATX_HEADING = /^\s{0,3}(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+function parseFarmMarkdownHeadings(markdown) {
+  const lines = markdown.split("\n");
+  const headings = [];
+  const used = /* @__PURE__ */ new Map();
+  let index = 0;
+  if (lines[0]?.trim() === "---") {
+    const close = lines.findIndex((line, lineIndex) => lineIndex > 0 && line.trim() === "---");
+    if (close > 0) index = close + 1;
+  }
+  let fence = null;
+  for (; index < lines.length; index++) {
+    const line = lines[index];
+    const fenceMatch = FENCE.exec(line);
+    if (fenceMatch) {
+      const marker = fenceMatch[1];
+      if (fence === null) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = null;
+      continue;
+    }
+    if (fence !== null) continue;
+    const match = ATX_HEADING.exec(line);
+    if (!match) continue;
+    const text = match[2].trim();
+    const base = slugifyHeading(text) || "section";
+    const count = used.get(base) ?? 0;
+    used.set(base, count + 1);
+    headings.push({
+      id: count === 0 ? base : `${base}-${count}`,
+      level: match[1].length,
+      text,
+      start: index,
+      end: lines.length
+    });
+  }
+  for (let headingIndex = 0; headingIndex < headings.length; headingIndex++) {
+    const heading = headings[headingIndex];
+    const next = headings.slice(headingIndex + 1).find((candidate) => candidate.level <= heading.level);
+    if (next) heading.end = next.start;
+  }
+  return headings;
+}
+__name(parseFarmMarkdownHeadings, "parseFarmMarkdownHeadings");
+function slugifyHeading(text) {
+  return text.replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[`*_~]/g, "").toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, "").trim().replace(/\s/g, "-");
+}
+__name(slugifyHeading, "slugifyHeading");
+function estimateFarmMarkdownTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+__name(estimateFarmMarkdownTokens, "estimateFarmMarkdownTokens");
+function selectFarmMarkdownView(markdown, searchParams, markdownPath) {
+  const wantsOutline = searchParams.has("outline");
+  const sectionId = searchParams.get("section");
+  if (!wantsOutline && sectionId === null) return { status: 200, body: markdown };
+  const lines = markdown.split("\n");
+  const headings = parseFarmMarkdownHeadings(markdown);
+  const sectionText = /* @__PURE__ */ __name((heading) => lines.slice(heading.start, heading.end).join("\n").trim(), "sectionText");
+  if (sectionId !== null) {
+    const heading = headings.find((candidate) => candidate.id === sectionId);
+    if (heading) return { status: 200, body: `${sectionText(heading)}
+` };
+    const available = headings.map((candidate) => `- \`${candidate.id}\``).join("\n");
+    return {
+      status: 404,
+      body: `# Section not found
+
+\`${sectionId}\` is not a section of ${markdownPath}.
+
+` + (available ? `Available sections:
+
+${available}
+` : "This page has no sections.\n")
+    };
+  }
+  const minLevel = Math.min(...headings.map((heading) => heading.level));
+  const entries = headings.map((heading) => {
+    const indent = "  ".repeat(heading.level - minLevel);
+    const tokens = estimateFarmMarkdownTokens(sectionText(heading));
+    return `${indent}- [${heading.text}](${markdownPath}?section=${encodeURIComponent(heading.id)}) ~${tokens} tokens`;
+  });
+  return {
+    status: 200,
+    body: `# Outline of ${markdownPath}
+
+About ${estimateFarmMarkdownTokens(markdown)} tokens in total. Request one section with \`?section=<id>\`.
+
+` + (entries.length > 0 ? `${entries.join("\n")}
+` : "This page has no headings.\n")
+  };
+}
+__name(selectFarmMarkdownView, "selectFarmMarkdownView");
+function selectFarmPageActionsView(markdownPath, actions, headers) {
+  headers.set("Content-Type", "application/json; charset=utf-8");
+  const page = markdownPath === "/index.md" ? "/" : markdownPath.replace(/\.md$/, "");
+  return {
+    status: 200,
+    body: `${JSON.stringify({ page, markdown: markdownPath, actions }, null, 2)}
+`
+  };
+}
+__name(selectFarmPageActionsView, "selectFarmPageActionsView");
+function createFarmMarkdownETag(body) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let index = 0; index < body.length; index++) {
+    const code = body.charCodeAt(index);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hash = (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+  return `W/"${hash}-${body.length.toString(36)}"`;
+}
+__name(createFarmMarkdownETag, "createFarmMarkdownETag");
+function ifNoneMatchIncludes(header, etag) {
+  if (!header) return false;
+  const opaque = etag.replace(/^W\//, "");
+  return header.split(",").map((token) => token.trim()).some((token) => token === "*" || token.replace(/^W\//, "") === opaque);
+}
+__name(ifNoneMatchIncludes, "ifNoneMatchIncludes");
+function createFarmMarkdownViewResponse(options) {
+  const url = options.requestUrl ?? new URL(options.request.url);
+  const view = url.searchParams.has("actions") ? selectFarmPageActionsView(options.markdownPath, options.actions ?? [], options.headers) : selectFarmMarkdownView(options.markdown, url.searchParams, options.markdownPath);
+  const status = view.status === 200 ? options.status : view.status;
+  const etag = createFarmMarkdownETag(view.body);
+  options.headers.set("ETag", etag);
+  if (status === 200 && ifNoneMatchIncludes(options.request.headers.get("if-none-match"), etag)) {
+    return new Response(null, { status: 304, headers: options.headers });
+  }
+  return new Response(options.request.method === "HEAD" ? null : view.body, {
+    status,
+    headers: options.headers
+  });
+}
+__name(createFarmMarkdownViewResponse, "createFarmMarkdownViewResponse");
+
 // src/markdown.ts
 var FARM_MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8";
 function farmRequestWantsMarkdown(pathname, accept) {
@@ -80,6 +220,7 @@ async function createMarkdownMirrorResponse(options) {
   }
   const pageUrl = new URL(options.request.url);
   pageUrl.pathname = target.pathname;
+  for (const name of ["outline", "section", "actions"]) pageUrl.searchParams.delete(name);
   const headers = new Headers(options.request.headers);
   headers.set("accept", "text/html");
   const pageResponse = await options.renderPage(
@@ -89,17 +230,25 @@ async function createMarkdownMirrorResponse(options) {
     })
   );
   if (!isHtmlResponse(pageResponse)) {
-    return null;
+    return createMarkdownAccessResponse(
+      pageResponse,
+      target.pathname,
+      pageUrl,
+      options.request.method === "HEAD"
+    );
   }
   const html = await pageResponse.text();
+  const markdownPath = target.pathname === "/" ? "/index.md" : `${target.pathname}.md`;
+  const actions = extractFarmPageActions(html, pageUrl);
   const markdown = htmlToMarkdown(html, {
     title: target.route?.title,
     includeMetadata: options.config?.includeMetadata ?? true,
-    sourcePath: target.pathname
+    sourcePath: target.pathname,
+    actionsPath: actions.length > 0 ? `${markdownPath}?actions` : void 0
   });
   const headersOut = new Headers({
     "Content-Type": "text/markdown; charset=utf-8",
-    "Content-Location": target.pathname === "/" ? "/index.md" : `${target.pathname}.md`,
+    "Content-Location": markdownPath,
     "X-Farm-Markdown-Route": target.pathname
   });
   if (!hasMarkdownExtension) {
@@ -115,12 +264,62 @@ async function createMarkdownMirrorResponse(options) {
     "Cache-Control",
     pageCacheControl && isPrivateCacheControl(pageCacheControl) ? pageCacheControl : createMarkdownCacheHeader(cache)
   );
-  return new Response(options.request.method === "HEAD" ? null : markdown, {
+  const robots = [pageResponse.headers.get("x-robots-tag"), readHtmlMetaContent(html, "robots")].filter((value) => Boolean(value?.trim())).join(", ");
+  if (robots) headersOut.set("X-Robots-Tag", robots);
+  const canonical = readHtmlCanonicalHref(html);
+  if (canonical) {
+    try {
+      headersOut.append("Link", `<${new URL(canonical, pageUrl).href}>; rel="canonical"`);
+    } catch {
+    }
+  }
+  return createFarmMarkdownViewResponse({
+    request: options.request,
+    requestUrl,
+    markdown,
     status: pageResponse.status,
-    headers: headersOut
+    headers: headersOut,
+    markdownPath,
+    actions
   });
 }
 __name(createMarkdownMirrorResponse, "createMarkdownMirrorResponse");
+function createMarkdownAccessResponse(pageResponse, pathname, pageUrl, head) {
+  const location = pageResponse.headers.get("location");
+  const redirect = pageResponse.status >= 300 && pageResponse.status < 400 && location;
+  if (!redirect && pageResponse.status !== 401 && pageResponse.status !== 403) return null;
+  const headers = new Headers({
+    "Content-Type": "text/markdown; charset=utf-8",
+    "Cache-Control": "no-store",
+    "X-Farm-Markdown-Route": pathname
+  });
+  let body;
+  if (redirect) {
+    let target;
+    try {
+      target = new URL(location, pageUrl).href;
+    } catch {
+      return null;
+    }
+    headers.set("Location", location);
+    body = `# Redirected
+
+\`${pathname}\` redirects to [${target}](${target}). The page may require signing in.
+`;
+  } else {
+    const authenticate = pageResponse.headers.get("www-authenticate");
+    if (authenticate) headers.set("WWW-Authenticate", authenticate);
+    body = pageResponse.status === 401 ? `# Sign-in required
+
+\`${pathname}\` requires signing in.
+` : `# Access denied
+
+This account cannot read \`${pathname}\`.
+`;
+  }
+  return new Response(head ? null : body, { status: pageResponse.status, headers });
+}
+__name(createMarkdownAccessResponse, "createMarkdownAccessResponse");
 function applyMarkdownNegotiationHeaders(response, options) {
   if (!isHtmlResponse(response)) {
     return response;
@@ -145,24 +344,17 @@ var BLOCK_TAGS = /<\/?(ul|ol|main|section|article|header|footer|nav|aside|div|fo
 var BOX_TAGS = /<\/?(label|button|input|select|textarea|option|output|meter|progress|td|th)\b[^>]*>/gi;
 function htmlToMarkdown(html, options = {}) {
   const title = options.title ?? extractHtmlTitle(html);
-  const streamed = readStreamedBoundaryInstructions(html);
-  let source = extractHtmlBody(
-    removeHiddenElements(
-      resolveStreamedBoundaries(
-        html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, ""),
-        streamed
-      ).replace(/<!--[\s\S]*?-->/g, "")
-    )
-  );
+  let source = readHtmlContentRegion(html);
   const codeBlocks = [];
-  const setAsideCodeBlock = /* @__PURE__ */ __name((_, code) => {
+  const setAsideCodeBlock = /* @__PURE__ */ __name((code, attributes) => {
     const content = decodeHtml(stripTags(code)).trim();
     const longestRun = (content.match(/`+/g) ?? []).reduce(
       (longest, run) => Math.max(longest, run.length),
       0
     );
     const fence = "`".repeat(Math.max(3, longestRun + 1));
-    codeBlocks.push(`${fence}
+    const language = readCodeLanguage(attributes) ?? "";
+    codeBlocks.push(`${fence}${language}
 ${content}
 ${fence}`);
     return `
@@ -172,10 +364,27 @@ ${CODE_BLOCK_MARK}${codeBlocks.length - 1}${CODE_BLOCK_MARK}
 `;
   }, "setAsideCodeBlock");
   source = source.replace(
-    /<pre\b[^>]*><code\b[^>]*>([\s\S]*?)<\/code><\/pre>/gi,
-    setAsideCodeBlock
+    /<pre\b([^>]*)><code\b([^>]*)>([\s\S]*?)<\/code><\/pre>/gi,
+    (_, preAttributes, codeAttributes, code) => setAsideCodeBlock(code, [codeAttributes, preAttributes])
+  );
+  source = source.replace(
+    /<pre\b([^>]*)>([\s\S]*?)<\/pre>/gi,
+    (_, attributes, code) => setAsideCodeBlock(code, [attributes])
+  );
+  source = source.replace(
+    /<table\b[^>]*>([\s\S]*?)<\/table>/gi,
+    (table, content) => {
+      if (/<table\b/i.test(content) || content.includes(CODE_BLOCK_MARK)) return table;
+      const rows = toMarkdownTableRows(content);
+      if (!rows) return table;
+      codeBlocks.push(rows);
+      return `
+
+${CODE_BLOCK_MARK}${codeBlocks.length - 1}${CODE_BLOCK_MARK}
+
+`;
+    }
   );
-  source = source.replace(/<pre\b[^>]*>([\s\S]*?)<\/pre>/gi, setAsideCodeBlock);
   source = source.replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, content) => {
     return `
 
@@ -205,6 +414,21 @@ ${quote}
 
 `;
   });
+  source = source.replace(
+    /<ol\b([^>]*)>([\s\S]*?)<\/ol>/gi,
+    (list, attributes, content) => {
+      if (/<[ou]l\b/i.test(content)) return list;
+      const start = Number.parseInt(readHtmlAttribute(attributes, "start") ?? "1", 10);
+      let number = Number.isFinite(start) ? start : 1;
+      const items = content.replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, (_, item) => {
+        return `
+${number++}. ${toInlineMarkdown(item).trim()}`;
+      });
+      return `
+${items}
+`;
+    }
+  );
   source = source.replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, (_, content) => {
     return `
 - ${toInlineMarkdown(content).trim()}`;
@@ -219,6 +443,9 @@ ${quote}
     if (options.sourcePath) {
       metadata.push(`Source: ${options.sourcePath}`);
     }
+    if (options.actionsPath) {
+      metadata.push(`Actions: ${options.actionsPath}`);
+    }
     if (metadata.length) {
       markdown = `${metadata.join("\n\n")}${markdown ? `
 
@@ -367,13 +594,28 @@ function extractHtmlTitle(html) {
   return match ? decodeHtml(stripTags(match[1])).trim() : void 0;
 }
 __name(extractHtmlTitle, "extractHtmlTitle");
+function readHtmlContentRegion(html) {
+  const streamed = readStreamedBoundaryInstructions(html);
+  return extractHtmlBody(
+    removeHiddenElements(
+      resolveStreamedBoundaries(
+        html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, ""),
+        streamed
+      ).replace(/<!--[\s\S]*?-->/g, "")
+    )
+  );
+}
+__name(readHtmlContentRegion, "readHtmlContentRegion");
 function extractHtmlBody(html) {
   const rootMatch = html.match(
     /<div\b[^>]*id=["']root["'][^>]*>([\s\S]*?)<\/div>\s*(?:<script|<\/body>|$)/i
   );
   const bodyMatch = html.match(/<body\b[^>]*>([\s\S]*?)<\/body>/i);
   const body = rootMatch ? rootMatch[1] : bodyMatch ? bodyMatch[1] : html;
-  return extractFirstElementContent(body, ["main", "article"]) ?? body;
+  const main = extractFirstElementContent(body, ["main"]);
+  if (main !== void 0) return main;
+  const articles = body.match(/<article\b/gi)?.length ?? 0;
+  return articles === 1 ? extractFirstElementContent(body, ["article"]) ?? body : body;
 }
 __name(extractHtmlBody, "extractHtmlBody");
 function extractFirstElementContent(html, tagNames) {
@@ -386,16 +628,249 @@ function extractFirstElementContent(html, tagNames) {
   return void 0;
 }
 __name(extractFirstElementContent, "extractFirstElementContent");
+function readHtmlMetaContent(html, name) {
+  for (const match of html.matchAll(/<meta\b([^>]*)>/gi)) {
+    if (readHtmlAttribute(match[1], "name")?.toLowerCase() === name) {
+      return readHtmlAttribute(match[1], "content");
+    }
+  }
+  return void 0;
+}
+__name(readHtmlMetaContent, "readHtmlMetaContent");
+function readHtmlCanonicalHref(html) {
+  for (const match of html.matchAll(/<link\b([^>]*)>/gi)) {
+    const rel = readHtmlAttribute(match[1], "rel")?.toLowerCase().split(/\s+/);
+    if (rel?.includes("canonical")) return readHtmlAttribute(match[1], "href");
+  }
+  return void 0;
+}
+__name(readHtmlCanonicalHref, "readHtmlCanonicalHref");
+var FORM_ENCTYPES = /* @__PURE__ */ new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+function extractFarmPageActions(html, pageUrl) {
+  if (!/<form\b/i.test(html)) return [];
+  const region = readHtmlContentRegion(html);
+  const labelsFor = /* @__PURE__ */ new Map();
+  for (const match of region.matchAll(/<label\b([^>]*)>([\s\S]*?)<\/label>/gi)) {
+    const target = readDecodedAttribute(match[1], "for");
+    if (target && !labelsFor.has(target)) labelsFor.set(target, readLabelText(match[2]));
+  }
+  const actions = [];
+  for (const form of region.matchAll(/<form\b([^>]*)>([\s\S]*?)<\/form>/gi)) {
+    const action = readPageForm(form[1], form[2], pageUrl, labelsFor);
+    if (action) actions.push(action);
+  }
+  return actions;
+}
+__name(extractFarmPageActions, "extractFarmPageActions");
+function readPageForm(attributes, content, pageUrl, labelsFor) {
+  const method = readDecodedAttribute(attributes, "method")?.trim().toLowerCase();
+  if (method === "dialog") return void 0;
+  const target = resolveFormTarget(readDecodedAttribute(attributes, "action"), pageUrl);
+  const form = {
+    type: "form",
+    method: method === "post" ? "POST" : "GET",
+    fields: [],
+    submit: []
+  };
+  const name = readDecodedAttribute(attributes, "aria-label") ?? readDecodedAttribute(attributes, "name") ?? readDecodedAttribute(attributes, "id");
+  if (name?.trim()) form.name = name.trim();
+  if (target) form.action = target;
+  else form.requiresJavaScript = true;
+  if (form.method === "POST") {
+    const enctype = readDecodedAttribute(attributes, "enctype")?.trim().toLowerCase();
+    form.enctype = enctype && FORM_ENCTYPES.has(enctype) ? enctype : "application/x-www-form-urlencoded";
+  }
+  const wrappingLabels = [...content.matchAll(/<label\b[^>]*>([\s\S]*?)<\/label>/gi)].map(
+    (match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      text: readLabelText(match[1])
+    })
+  );
+  const labelOf = /* @__PURE__ */ __name((controlAttributes, index) => {
+    const aria = readDecodedAttribute(controlAttributes, "aria-label")?.trim();
+    if (aria) return aria;
+    const id = readDecodedAttribute(controlAttributes, "id");
+    const forLabel = id ? labelsFor.get(id) : void 0;
+    if (forLabel) return forLabel;
+    const wrapping = wrappingLabels.find((label) => label.start < index && index < label.end);
+    return wrapping?.text || void 0;
+  }, "labelOf");
+  const groups = /* @__PURE__ */ new Map();
+  const controls = /<(input)\b([^>]*)>|<(select|textarea|button)\b([^>]*)>([\s\S]*?)<\/\3>/gi;
+  for (const match of content.matchAll(controls)) {
+    const tag = (match[1] ?? match[3]).toLowerCase();
+    const controlAttributes = match[2] ?? match[4];
+    const inner = match[5] ?? "";
+    if (hasHtmlAttribute(controlAttributes, "disabled")) continue;
+    const label = labelOf(controlAttributes, match.index);
+    const fieldName = readDecodedAttribute(controlAttributes, "name");
+    const typeAttribute = readDecodedAttribute(controlAttributes, "type")?.trim().toLowerCase();
+    const type = tag === "input" ? typeAttribute ?? "text" : tag === "button" ? typeAttribute ?? "submit" : tag;
+    if (tag === "button" && !["button", "reset"].includes(type) || tag === "input" && (type === "submit" || type === "image")) {
+      const submit = {
+        label: (tag === "button" ? readLabelText(inner) : "") || readDecodedAttribute(controlAttributes, "value") || readDecodedAttribute(controlAttributes, "alt") || label || "Submit"
+      };
+      if (fieldName) submit.name = fieldName;
+      const value = readDecodedAttribute(controlAttributes, "value");
+      if (fieldName && value !== void 0) submit.value = value;
+      const formAction = readDecodedAttribute(controlAttributes, "formaction");
+      if (formAction !== void 0) {
+        const resolved = resolveFormTarget(formAction, pageUrl);
+        if (resolved) submit.action = resolved;
+      }
+      const formMethod = readDecodedAttribute(controlAttributes, "formmethod")?.toLowerCase();
+      if (formMethod === "get" || formMethod === "post") submit.method = formMethod.toUpperCase();
+      form.submit.push(submit);
+      continue;
+    }
+    if (tag === "button" || type === "button" || type === "reset" || !fieldName) continue;
+    if (type === "hidden") {
+      const value = readDecodedAttribute(controlAttributes, "value") ?? "";
+      form.fields.push({ name: fieldName, type, value });
+      if (fieldName.startsWith("$ACTION_ID_")) {
+        form.serverAction ?? (form.serverAction = { id: fieldName.slice("$ACTION_ID_".length) });
+      } else if (/^\$ACTION_[^:]*:0$/.test(fieldName)) {
+        try {
+          const id = JSON.parse(value).id;
+          if (typeof id === "string") form.serverAction ?? (form.serverAction = { id });
+        } catch {
+        }
+      }
+      continue;
+    }
+    if (type === "radio" || type === "checkbox") {
+      const value = readDecodedAttribute(controlAttributes, "value") ?? "on";
+      const option = { value };
+      if (label) option.label = label;
+      if (hasHtmlAttribute(controlAttributes, "checked")) option.selected = true;
+      const group = groups.get(fieldName);
+      if (group) {
+        group.options.push(option);
+        if (hasHtmlAttribute(controlAttributes, "required")) group.required = true;
+        continue;
+      }
+      const field2 = { name: fieldName, type, options: [option] };
+      if (hasHtmlAttribute(controlAttributes, "required")) field2.required = true;
+      groups.set(fieldName, field2);
+      form.fields.push(field2);
+      continue;
+    }
+    const field = { name: fieldName, type };
+    if (label) field.label = label;
+    if (hasHtmlAttribute(controlAttributes, "required")) field.required = true;
+    if (hasHtmlAttribute(controlAttributes, "multiple")) field.multiple = true;
+    if (tag === "select") {
+      field.options = [...inner.matchAll(/<option\b([^>]*)>([\s\S]*?)(?=<\/option>|<option\b|$)/gi)].filter((option) => !hasHtmlAttribute(option[1], "disabled")).map((option) => {
+        const text = readLabelText(option[2]);
+        const entry = {
+          value: readDecodedAttribute(option[1], "value") ?? text
+        };
+        if (text && text !== entry.value) entry.label = text;
+        if (hasHtmlAttribute(option[1], "selected")) entry.selected = true;
+        return entry;
+      });
+    } else if (tag === "textarea") {
+      const value = decodeHtml(inner);
+      if (value) field.value = value;
+    } else {
+      const value = readDecodedAttribute(controlAttributes, "value");
+      if (value !== void 0 && type !== "password" && type !== "file") field.value = value;
+    }
+    for (const key of ["placeholder", "pattern", "min", "max", "step", "accept"]) {
+      const value = readDecodedAttribute(controlAttributes, key);
+      if (value !== void 0) field[key] = value;
+    }
+    for (const [attribute, key] of [
+      ["minlength", "minLength"],
+      ["maxlength", "maxLength"]
+    ]) {
+      const value = Number.parseInt(readDecodedAttribute(controlAttributes, attribute) ?? "", 10);
+      if (Number.isFinite(value) && value >= 0) field[key] = value;
+    }
+    form.fields.push(field);
+  }
+  if (form.fields.length === 0 && form.submit.length === 0) return void 0;
+  if (form.submit.length === 0) form.submit.push({ label: "Submit" });
+  return form;
+}
+__name(readPageForm, "readPageForm");
+function resolveFormTarget(action, pageUrl) {
+  let target;
+  try {
+    target = new URL(action?.trim() || pageUrl.href, pageUrl);
+  } catch {
+    return void 0;
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") return void 0;
+  target.hash = "";
+  return target.origin === pageUrl.origin ? `${target.pathname}${target.search}` : target.href;
+}
+__name(resolveFormTarget, "resolveFormTarget");
+function readLabelText(html) {
+  return decodeHtml(stripTags(html.replace(/<(select|textarea|button)\b[\s\S]*?<\/\1>/gi, " "))).replace(/\s+/g, " ").trim();
+}
+__name(readLabelText, "readLabelText");
+function readDecodedAttribute(attributes, name) {
+  const value = readHtmlAttribute(attributes, name);
+  return value === void 0 ? void 0 : decodeHtml(value);
+}
+__name(readDecodedAttribute, "readDecodedAttribute");
+function hasHtmlAttribute(attributes, name) {
+  return new RegExp(`(?:^|\\s)${name}(?=\\s|=|/|$)`, "i").test(attributes);
+}
+__name(hasHtmlAttribute, "hasHtmlAttribute");
+function readHtmlAttribute(attributes, name) {
+  const match = new RegExp(
+    `(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\`]+))`,
+    "i"
+  ).exec(attributes);
+  return match ? match[1] ?? match[2] ?? match[3] : void 0;
+}
+__name(readHtmlAttribute, "readHtmlAttribute");
+function readCodeLanguage(attributesList) {
+  for (const attributes of attributesList) {
+    const language = readHtmlAttribute(attributes, "data-language") ?? readHtmlAttribute(attributes, "data-lang") ?? readHtmlAttribute(attributes, "class")?.match(/(?:^|\s)lang(?:uage)?-(\S+)/)?.[1];
+    if (language && /^[\w#+.-]+$/.test(language)) return language;
+  }
+  return void 0;
+}
+__name(readCodeLanguage, "readCodeLanguage");
+function toMarkdownTableRows(content) {
+  const rows = [];
+  for (const [, row] of content.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/gi)) {
+    const cells = [];
+    for (const [, , attributes, cell] of row.matchAll(/<(td|th)\b([^>]*)>([\s\S]*?)<\/\1>/gi)) {
+      cells.push(decodeHtml(toInlineMarkdown(cell)).trim().replace(/\|/g, "\\|"));
+      const span = Number.parseInt(readHtmlAttribute(attributes, "colspan") ?? "1", 10);
+      for (let extra = 1; extra < Math.min(span, 1e3); extra++) cells.push("");
+    }
+    if (cells.length) rows.push(cells);
+  }
+  if (!rows.length) return void 0;
+  const columns = rows.reduce((widest, row) => Math.max(widest, row.length), 0);
+  const line = /* @__PURE__ */ __name((cells) => `| ${Array.from({ length: columns }, (_, index) => cells[index] ?? "").join(" | ")} |`.replace(
+    / {2,}/g,
+    " "
+  ), "line");
+  return [line(rows[0]), line(Array(columns).fill("---")), ...rows.slice(1).map(line)].join("\n");
+}
+__name(toMarkdownTableRows, "toMarkdownTableRows");
 function toInlineMarkdown(html) {
   let source = html.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text) => {
     const label = toInlineMarkdown(text).trim() || href;
     return `[${label}](${href})`;
-  }).replace(
-    /<img\b[^>]*src=["']([^"']+)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi,
-    (_, src, alt) => {
-      return `![${alt}](${src})`;
-    }
-  ).replace(/<strong\b[^>]*>([\s\S]*?)<\/strong>/gi, (_, content) => {
+  }).replace(/<img\b([^>]*)>/gi, (_, attributes) => {
+    const src = readHtmlAttribute(attributes, "src");
+    const alt = readHtmlAttribute(attributes, "alt") ?? "";
+    if (!src) return alt;
+    if (/^data:/i.test(src.trim())) return alt;
+    return `![${alt}](${src})`;
+  }).replace(/<strong\b[^>]*>([\s\S]*?)<\/strong>/gi, (_, content) => {
     return `**${toInlineMarkdown(content).trim()}**`;
   }).replace(/<b\b[^>]*>([\s\S]*?)<\/b>/gi, (_, content) => {
     return `**${toInlineMarkdown(content).trim()}**`;
@@ -583,6 +1058,7 @@ function decodeHtml(input) {
 __name(decodeHtml, "decodeHtml");
 
 export {
+  createFarmMarkdownViewResponse,
   FARM_MARKDOWN_CONTENT_TYPE,
   farmRequestWantsMarkdown,
   createFarmMarkdownErrorBody,
@@ -596,5 +1072,6 @@ export {
   getFarmMarkdownMirrorPath,
   getFarmMarkdownAlternatePath,
   isFarmMarkdownMirrorExposed,
-  matchesFarmMarkdownRoutePattern
+  matchesFarmMarkdownRoutePattern,
+  extractFarmPageActions
 };

package/dist/{chunk-YJJLXIIS.cjs → chunk-U74A3P2P.cjs}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkXI3GWPUScjs = require('./chunk-XI3GWPUS.cjs');
+var _chunkCRQPYWLKcjs = require('./chunk-CRQPYWLK.cjs');
 
 
-var _chunk2QLBIPFTcjs = require('./chunk-2QLBIPFT.cjs');
+var _chunkB6ZCT36Xcjs = require('./chunk-B6ZCT36X.cjs');
 
 
 var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
@@ -13,7 +13,7 @@ var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
 // src/navigation.ts
 function useRouter2() {
-  const router = _chunkXI3GWPUScjs.useRouter.call(void 0, );
+  const router = _chunkCRQPYWLKcjs.useRouter.call(void 0, );
   return {
     push: router.push,
     replace: router.replace,
@@ -21,21 +21,21 @@ function useRouter2() {
     forward: router.forward,
     refresh() {
       if (typeof window === "undefined") return Promise.resolve();
-      return _chunk2QLBIPFTcjs.getRouter.call(void 0, ).refresh();
+      return _chunkB6ZCT36Xcjs.getRouter.call(void 0, ).refresh();
     },
     prefetch(href) {
       if (typeof window === "undefined") return Promise.resolve();
-      return _chunk2QLBIPFTcjs.getRouter.call(void 0, ).prefetch(_chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href));
+      return _chunkB6ZCT36Xcjs.getRouter.call(void 0, ).prefetch(_chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href));
     }
   };
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, useRouter2, "useRouter");
 function usePathname() {
-  return _chunkXI3GWPUScjs.useRouter.call(void 0, ).pathname;
+  return _chunkCRQPYWLKcjs.useRouter.call(void 0, ).pathname;
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, usePathname, "usePathname");
 function useSearchParams() {
-  return _chunkXI3GWPUScjs.useRouter.call(void 0, ).searchParams;
+  return _chunkCRQPYWLKcjs.useRouter.call(void 0, ).searchParams;
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, useSearchParams, "useSearchParams");