@farm.js/core 0.1.24 → 0.1.26

package/dist/chunk-OOIL3BWR.mjs

@@ -0,0 +1,1229 @@
+import {
+  emitFarmAgentRead
+} from "./chunk-MVL2RAJW.mjs";
+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
+    });
+  }
+  const open = [];
+  for (const heading of headings) {
+    while (open.length > 0 && open[open.length - 1].level >= heading.level) {
+      open.pop().end = heading.start;
+    }
+    open.push(heading);
+  }
+  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");
+var FARM_MARKDOWN_MIN_TOKEN_BUDGET = 100;
+var FARM_MARKDOWN_VIEW_PARAMS = [
+  "outline",
+  "section",
+  "actions",
+  "max_tokens",
+  "cursor"
+];
+function selectFarmMarkdownView(markdown, searchParams, markdownPath) {
+  const wantsOutline = searchParams.has("outline");
+  const sectionId = searchParams.get("section");
+  const budget = searchParams.get("max_tokens");
+  if (!wantsOutline && sectionId === null && budget === null)
+    return { status: 200, body: markdown };
+  const viewUrl = /* @__PURE__ */ __name((view) => {
+    const query = new URLSearchParams(searchParams);
+    for (const name of FARM_MARKDOWN_VIEW_PARAMS) query.delete(name);
+    for (const [name, value] of Object.entries(view)) {
+      if (value !== null && value !== void 0) query.set(name, value);
+    }
+    const search = query.toString();
+    return search ? `${markdownPath}?${search}` : markdownPath;
+  }, "viewUrl");
+  const withinBudget = /* @__PURE__ */ __name((document) => budget === null ? { status: 200, body: document } : selectFarmMarkdownPart(
+    document,
+    budget,
+    searchParams.get("cursor"),
+    (cursor) => viewUrl({ section: sectionId, max_tokens: budget, cursor })
+  ), "withinBudget");
+  if (!wantsOutline && sectionId === null) return withinBudget(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 withinBudget(`${sectionText(heading)}
+`);
+    const available = headings.map((candidate) => `- \`${candidate.id}\``).join("\n");
+    return {
+      status: 404,
+      body: `# Section not found
+
+${markdownCodeSpan(sectionId)} is not a section of ${markdownPath}.
+
+` + (available ? `Available sections:
+
+${available}
+` : "This page has no sections.\n")
+    };
+  }
+  const minLevel = headings.reduce((min, heading) => Math.min(min, heading.level), 6);
+  const entries = headings.map((heading) => {
+    const indent = "  ".repeat(heading.level - minLevel);
+    const tokens = estimateFarmMarkdownTokens(sectionText(heading));
+    return `${indent}- [${heading.text}](${viewUrl({ section: heading.id })}) ~${tokens} tokens`;
+  });
+  return {
+    status: 200,
+    body: `# Outline of ${markdownPath}
+
+About ${estimateFarmMarkdownTokens(markdown)} tokens in total. Request one section with \`?section=<id>\`, or read in parts with \`?max_tokens=<n>\`.
+
+` + (entries.length > 0 ? `${entries.join("\n")}
+` : "This page has no headings.\n")
+  };
+}
+__name(selectFarmMarkdownView, "selectFarmMarkdownView");
+function markdownCodeSpan(value) {
+  const text = value.replace(/[\p{Cc}\u2028\u2029]+/gu, " ");
+  const longestRun = (text.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
+  const fence = "`".repeat(longestRun + 1);
+  const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+  return `${fence}${pad}${text}${pad}${fence}`;
+}
+__name(markdownCodeSpan, "markdownCodeSpan");
+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 selectFarmMarkdownPart(document, rawBudget, rawCursor, partUrl) {
+  const budget = /^\d{1,9}$/.test(rawBudget) ? Number(rawBudget) : Number.NaN;
+  if (!(budget >= FARM_MARKDOWN_MIN_TOKEN_BUDGET)) {
+    return {
+      status: 400,
+      body: `# Invalid max_tokens
+
+\`max_tokens\` must be a whole number of at least ${FARM_MARKDOWN_MIN_TOKEN_BUDGET}.
+`
+    };
+  }
+  const lines = document.replace(/\n$/, "").split("\n");
+  const version = hashFarmMarkdown(document).slice(0, 8);
+  let start = 0;
+  if (rawCursor !== null) {
+    const match = /^(\d{1,9})\.([0-9a-z]+)$/.exec(rawCursor);
+    if (!match || Number(match[1]) <= 0 || Number(match[1]) >= lines.length) {
+      return {
+        status: 400,
+        body: `# Invalid cursor
+
+Start again at ${partUrl()}.
+`
+      };
+    }
+    if (match[2] !== version) {
+      return {
+        status: 409,
+        body: `# Page changed
+
+The page changed after this cursor was issued. Start again at ${partUrl()}.
+`
+      };
+    }
+    start = Number(match[1]);
+  }
+  const fences = readOpenFences(lines);
+  const reopen = fences[start];
+  const room = budget * 4 - 200;
+  let size = reopen ? reopen.opener.length + 1 : 0;
+  let end = start;
+  let lastBreak = -1;
+  while (end < lines.length) {
+    const length = lines[end].length + 1;
+    if (end > start && size + length > room) break;
+    size += length;
+    end++;
+    if (end < lines.length && isPartBreak(lines, fences, end)) lastBreak = end;
+  }
+  const head = reopen ? `${reopen.opener}
+` : "";
+  if (end >= lines.length) {
+    return { status: 200, body: `${head}${lines.slice(start).join("\n")}
+` };
+  }
+  if (lastBreak > start) end = lastBreak;
+  const open = fences[end];
+  const part = `${head}${lines.slice(start, end).join("\n").replace(/\n+$/, "")}${open ? `
+${open.closer}` : ""}`;
+  const next = partUrl(`${end}.${version}`);
+  const remaining = estimateFarmMarkdownTokens(lines.slice(end).join("\n"));
+  return {
+    status: 200,
+    body: `${part}
+
+---
+
+Continue: ${next} (about ${remaining} more tokens)
+`,
+    headers: { Link: `<${next}>; rel="next"` }
+  };
+}
+__name(selectFarmMarkdownPart, "selectFarmMarkdownPart");
+function readOpenFences(lines) {
+  const open = [];
+  let fence;
+  let frontMatter = lines[0]?.trim() === "---";
+  for (let index = 0; index < lines.length; index++) {
+    open.push(frontMatter && index > 0 ? { opener: "", closer: "" } : fence);
+    const line = lines[index];
+    if (frontMatter) {
+      if (index > 0 && line.trim() === "---") frontMatter = false;
+      continue;
+    }
+    const match = FENCE.exec(line);
+    if (!match) continue;
+    const marker = match[1];
+    if (!fence) fence = { opener: line.trim(), closer: marker, marker };
+    else if (marker[0] === fence.marker[0] && marker.length >= fence.marker.length)
+      fence = void 0;
+  }
+  return open;
+}
+__name(readOpenFences, "readOpenFences");
+function isPartBreak(lines, fences, index) {
+  if (fences[index]) return false;
+  return lines[index - 1].trim() === "" || ATX_HEADING.test(lines[index]);
+}
+__name(isPartBreak, "isPartBreak");
+function readMarkdownViewName(searchParams) {
+  if (searchParams.has("actions")) return "actions";
+  if (searchParams.has("outline")) return "outline";
+  if (searchParams.has("max_tokens")) return "parts";
+  return searchParams.has("section") ? "section" : void 0;
+}
+__name(readMarkdownViewName, "readMarkdownViewName");
+function createFarmMarkdownETag(body) {
+  return `W/"${hashFarmMarkdown(body)}-${body.length.toString(36)}"`;
+}
+__name(createFarmMarkdownETag, "createFarmMarkdownETag");
+function hashFarmMarkdown(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);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+__name(hashFarmMarkdown, "hashFarmMarkdown");
+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;
+  emitFarmAgentRead(options.request, "markdown", status, readMarkdownViewName(url.searchParams));
+  for (const [name, value] of Object.entries(view.headers ?? {}))
+    options.headers.append(name, value);
+  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) {
+  return pathname.toLowerCase().endsWith(".md") || requestAcceptsMarkdown(accept);
+}
+__name(farmRequestWantsMarkdown, "farmRequestWantsMarkdown");
+function createFarmMarkdownErrorBody(status, pathname, homeHref = "/") {
+  const heading = status === 404 ? "Page not found" : `Request failed (${status})`;
+  return `# ${heading}
+
+No page is available at \`${pathname}\`. The URL may be incorrect, or the page has not been published.
+
+Browse [the site homepage](${homeHref}) to find available pages.
+`;
+}
+__name(createFarmMarkdownErrorBody, "createFarmMarkdownErrorBody");
+function resolveMarkdownConfig(config) {
+  if (config === false) {
+    return {
+      enabled: false,
+      expose: [],
+      cache: false,
+      includeMetadata: true
+    };
+  }
+  if (config === true || config === void 0) {
+    return {
+      enabled: true,
+      expose: true,
+      cache: false,
+      includeMetadata: true
+    };
+  }
+  const exposeInput = config.expose ?? config.routes ?? true;
+  const expose = exposeInput === true ? true : Array.isArray(exposeInput) ? exposeInput.map(normalizeMarkdownRouteInput) : [];
+  return {
+    enabled: config.enabled !== false && (expose === true || expose.length > 0),
+    expose,
+    cache: config.cache ?? false,
+    includeMetadata: config.includeMetadata ?? true
+  };
+}
+__name(resolveMarkdownConfig, "resolveMarkdownConfig");
+function resolveMarkdownMirrorTarget(config, pathname, options = {}) {
+  const hasMarkdownExtension = pathname.toLowerCase().endsWith(".md");
+  if (!config?.enabled || !hasMarkdownExtension && !requestAcceptsMarkdown(options.accept)) {
+    return null;
+  }
+  const targetPathname = normalizeMarkdownRoute(
+    hasMarkdownExtension ? pathname.slice(0, -".md".length) || "/" : pathname
+  );
+  const route = findExposedMarkdownRoute(config, targetPathname);
+  if (!route && config.expose !== true) {
+    return null;
+  }
+  return {
+    pathname: targetPathname,
+    route
+  };
+}
+__name(resolveMarkdownMirrorTarget, "resolveMarkdownMirrorTarget");
+async function createMarkdownMirrorResponse(options) {
+  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
+    return null;
+  }
+  const requestUrl = options.requestUrl?.href === options.request.url ? options.requestUrl : new URL(options.request.url);
+  const hasMarkdownExtension = requestUrl.pathname.toLowerCase().endsWith(".md");
+  const target = resolveMarkdownMirrorTarget(options.config, requestUrl.pathname, {
+    accept: options.request.headers.get("accept")
+  });
+  if (!target) {
+    return null;
+  }
+  if (options.routeExists && !options.routeExists(target.pathname)) {
+    return null;
+  }
+  const pageUrl = new URL(options.request.url);
+  pageUrl.pathname = target.pathname;
+  for (const name of FARM_MARKDOWN_VIEW_PARAMS) pageUrl.searchParams.delete(name);
+  const headers = new Headers(options.request.headers);
+  headers.set("accept", "text/html");
+  const pageResponse = await options.renderPage(
+    new Request(pageUrl, {
+      method: "GET",
+      headers
+    })
+  );
+  const redirects = pageResponse.status >= 300 && pageResponse.status < 400 && pageResponse.headers.has("location");
+  if (redirects || !isHtmlResponse(pageResponse)) {
+    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,
+    actionsPath: actions.length > 0 ? `${markdownPath}?actions` : void 0
+  });
+  const headersOut = new Headers({
+    "Content-Type": "text/markdown; charset=utf-8",
+    "Content-Location": markdownPath,
+    "X-Farm-Markdown-Route": target.pathname
+  });
+  if (!hasMarkdownExtension) {
+    headersOut.set("Vary", "Accept");
+  }
+  for (const token of pageResponse.headers.get("vary")?.split(",") ?? []) {
+    const name = token.trim();
+    if (name && name.toLowerCase() !== "accept") appendHeaderToken(headersOut, "Vary", name);
+  }
+  const pageCacheControl = pageResponse.headers.get("cache-control");
+  const cache = target.route?.cache ?? options.config?.cache ?? false;
+  headersOut.set(
+    "Cache-Control",
+    pageCacheControl && isPrivateCacheControl(pageCacheControl) ? pageCacheControl : createMarkdownCacheHeader(cache)
+  );
+  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,
+    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;
+  }
+  const alternatePath = getFarmMarkdownAlternatePath(options.config, options.pathname);
+  if (!alternatePath) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  appendHeaderToken(headers, "Vary", "Accept");
+  headers.append("Link", `<${alternatePath}>; rel="alternate"; type="text/markdown"`);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+__name(applyMarkdownNegotiationHeaders, "applyMarkdownNegotiationHeaders");
+var CODE_BLOCK_MARK = "\0";
+var CODE_BLOCK_PLACEHOLDER = /\u0000(\d+)\u0000/g;
+var BLOCK_TAGS = /<\/?(ul|ol|main|section|article|header|footer|nav|aside|div|form|fieldset|legend|figure|figcaption|table|thead|tbody|tfoot|tr|dl|dt|dd|details|summary|address)\b[^>]*>/gi;
+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);
+  let source = readHtmlContentRegion(html);
+  const codeBlocks = [];
+  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));
+    const language = readCodeLanguage(attributes) ?? "";
+    codeBlocks.push(`${fence}${language}
+${content}
+${fence}`);
+    return `
+
+${CODE_BLOCK_MARK}${codeBlocks.length - 1}${CODE_BLOCK_MARK}
+
+`;
+  }, "setAsideCodeBlock");
+  source = source.replace(
+    /<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(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, content) => {
+    return `
+
+${"#".repeat(Number(level))} ${toInlineMarkdown(content).trim()}
+
+`;
+  });
+  source = source.replace(/<p\b[^>]*>([\s\S]*?)<\/p>/gi, (_, content) => {
+    return `
+
+${toInlineMarkdown(content).trim()}
+
+`;
+  });
+  source = source.replace(/<blockquote\b[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
+    const quote = htmlToMarkdown(content, { includeMetadata: false }).split("\n").filter((line) => line.trim().length > 0).map((line) => {
+      const code = line.startsWith(CODE_BLOCK_MARK) && line.endsWith(CODE_BLOCK_MARK) ? codeBlocks[Number(line.slice(1, -1))] : void 0;
+      if (code === void 0) return `> ${escapeHtmlText(line)}`;
+      codeBlocks.push(
+        code.split("\n").map((codeLine) => codeLine ? `> ${codeLine}` : ">").join("\n")
+      );
+      return `${CODE_BLOCK_MARK}${codeBlocks.length - 1}${CODE_BLOCK_MARK}`;
+    }).join("\n");
+    return `
+
+${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()}`;
+  });
+  source = source.replace(BLOCK_TAGS, "\n").replace(BOX_TAGS, " ").replace(/<br\s*\/?>/gi, "\n").replace(/<hr\s*\/?>/gi, "\n\n---\n\n");
+  let markdown = decodeHtml(stripTags(source)).split("\n").map((line) => line.replace(/[ \t]+/g, " ").trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim().replace(CODE_BLOCK_PLACEHOLDER, (match, index) => codeBlocks[Number(index)] ?? match);
+  if (options.includeMetadata !== false) {
+    const metadata = [];
+    if (title && !markdown.startsWith("# ")) {
+      metadata.push(`# ${title}`);
+    }
+    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 ? `
+
+${markdown}` : ""}`;
+    }
+  }
+  return `${markdown}
+`;
+}
+__name(htmlToMarkdown, "htmlToMarkdown");
+function normalizeMarkdownRouteInput(input) {
+  if (typeof input === "string") {
+    return {
+      route: normalizeMarkdownRoute(input)
+    };
+  }
+  return {
+    ...input,
+    route: normalizeMarkdownRoute(input.route)
+  };
+}
+__name(normalizeMarkdownRouteInput, "normalizeMarkdownRouteInput");
+function normalizeMarkdownRoute(route) {
+  const withoutMarkdownExtension = route.toLowerCase().endsWith(".md") ? route.slice(0, -3) : route;
+  const withSlash = withoutMarkdownExtension.startsWith("/") ? withoutMarkdownExtension : `/${withoutMarkdownExtension}`;
+  const normalized = withSlash.replace(/\/+/g, "/").replace(/\/$/g, "");
+  return normalized === "" || normalized === "/index" ? "/" : normalized;
+}
+__name(normalizeMarkdownRoute, "normalizeMarkdownRoute");
+function farmAcceptQuality(accept, mediaType, options = {}) {
+  if (!accept) return 0;
+  const target = mediaType.toLowerCase();
+  const [targetType] = target.split("/");
+  let best = 0;
+  for (const entry of accept.split(",")) {
+    const [candidate, ...parameters] = entry.trim().toLowerCase().split(";").map((part) => part.trim());
+    if (!candidate) continue;
+    const matches = candidate === target || options.wildcards === true && (candidate === "*/*" || candidate === `${targetType}/*`);
+    if (!matches) continue;
+    const quality = parameters.find((parameter) => parameter.startsWith("q="));
+    const value = quality === void 0 ? 1 : Number(quality.slice(2));
+    if (!Number.isFinite(value) || value <= 0) continue;
+    if (value > best) best = value;
+  }
+  return best;
+}
+__name(farmAcceptQuality, "farmAcceptQuality");
+function requestAcceptsMarkdown(accept) {
+  if (!accept) {
+    return false;
+  }
+  return accept.split(",").some((entry) => {
+    const [mediaType, ...parameters] = entry.trim().toLowerCase().split(";").map((part) => part.trim());
+    if (mediaType !== "text/markdown") {
+      return false;
+    }
+    const quality = parameters.find((parameter) => parameter.startsWith("q="));
+    return quality === void 0 || Number(quality.slice(2)) > 0;
+  });
+}
+__name(requestAcceptsMarkdown, "requestAcceptsMarkdown");
+function getMarkdownAlternatePath(pathname) {
+  return pathname === "/" ? "/index.md" : `${pathname}.md`;
+}
+__name(getMarkdownAlternatePath, "getMarkdownAlternatePath");
+function getFarmMarkdownMirrorPath(pathname) {
+  return getMarkdownAlternatePath(pathname);
+}
+__name(getFarmMarkdownMirrorPath, "getFarmMarkdownMirrorPath");
+function getFarmMarkdownAlternatePath(config, pathname) {
+  const target = resolveMarkdownMirrorTarget(config, pathname, { accept: "text/markdown" });
+  return target ? getMarkdownAlternatePath(target.pathname) : null;
+}
+__name(getFarmMarkdownAlternatePath, "getFarmMarkdownAlternatePath");
+function isFarmMarkdownMirrorExposed(config, pathname) {
+  if (!config?.enabled) return false;
+  return config.expose === true || findExposedMarkdownRoute(config, pathname) !== null;
+}
+__name(isFarmMarkdownMirrorExposed, "isFarmMarkdownMirrorExposed");
+function matchesFarmMarkdownRoutePattern(pattern, pathname) {
+  return routeMatches(pattern, pathname);
+}
+__name(matchesFarmMarkdownRoutePattern, "matchesFarmMarkdownRoutePattern");
+function appendHeaderToken(headers, name, token) {
+  const current = headers.get(name);
+  if (!current) {
+    headers.set(name, token);
+    return;
+  }
+  const tokens = current.split(",").map((value) => value.trim().toLowerCase());
+  if (!tokens.includes(token.toLowerCase())) {
+    headers.set(name, `${current}, ${token}`);
+  }
+}
+__name(appendHeaderToken, "appendHeaderToken");
+function findExposedMarkdownRoute(config, pathname) {
+  if (config.expose === true) {
+    return null;
+  }
+  return config.expose.find((route) => routeMatches(route.route, pathname)) ?? null;
+}
+__name(findExposedMarkdownRoute, "findExposedMarkdownRoute");
+function routeMatches(pattern, pathname) {
+  if (pattern === pathname) {
+    return true;
+  }
+  let source = "";
+  pattern.split("/").forEach((segment, index) => {
+    if (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment)) {
+      source += "(?:/.*)?";
+      return;
+    }
+    const prefix = index === 0 ? "" : "/";
+    if (/^\[\.\.\.[^\]]+\]$/.test(segment)) {
+      source += `${prefix}.*`;
+    } else if (/^\[[^\]]+\]$/.test(segment)) {
+      source += `${prefix}[^/]+`;
+    } else {
+      source += prefix + segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+  });
+  return new RegExp(`^${source}$`).test(pathname);
+}
+__name(routeMatches, "routeMatches");
+function isHtmlResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  return contentType.includes("text/html");
+}
+__name(isHtmlResponse, "isHtmlResponse");
+function isPrivateCacheControl(value) {
+  return value.split(",").some((directive) => {
+    const name = directive.split("=", 1)[0].trim().toLowerCase();
+    return name === "private" || name === "no-store";
+  });
+}
+__name(isPrivateCacheControl, "isPrivateCacheControl");
+function createMarkdownCacheHeader(cache) {
+  if (cache === false || cache <= 0) {
+    return "no-store";
+  }
+  return `public, max-age=${cache}, s-maxage=${cache}`;
+}
+__name(createMarkdownCacheHeader, "createMarkdownCacheHeader");
+function extractHtmlTitle(html) {
+  const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+  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;
+  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) {
+  for (const tagName of tagNames) {
+    const match = html.match(new RegExp(`<${tagName}\\b[^>]*>([\\s\\S]*?)<\\/${tagName}>`, "i"));
+    if (match) {
+      return match[1];
+    }
+  }
+  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([^>]*)>/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()}**`;
+  }).replace(/<em\b[^>]*>([\s\S]*?)<\/em>/gi, (_, content) => {
+    return `_${toInlineMarkdown(content).trim()}_`;
+  }).replace(/<i\b[^>]*>([\s\S]*?)<\/i>/gi, (_, content) => {
+    return `_${toInlineMarkdown(content).trim()}_`;
+  }).replace(/<code\b[^>]*>([\s\S]*?)<\/code>/gi, (_, content) => {
+    return `\`${stripTags(content).trim()}\``;
+  }).replace(/<br\s*\/?>/gi, "\n").replace(BLOCK_TAGS, " ").replace(BOX_TAGS, " ");
+  return stripTags(source).replace(/\s+/g, " ");
+}
+__name(toInlineMarkdown, "toInlineMarkdown");
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+function removeHiddenElements(html) {
+  const openingTag = /<([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+  let closingTags;
+  let result = "";
+  let cursor = 0;
+  let match;
+  while (match = openingTag.exec(html)) {
+    const [tag, name, attributes] = match;
+    if (!isHiddenElement(attributes)) continue;
+    const start = match.index;
+    let end = start + tag.length;
+    if (!VOID_TAGS.has(name.toLowerCase()) && !isSelfClosingTag(tag)) {
+      closingTags ?? (closingTags = matchClosingTags(html));
+      const close = closingTags.get(start);
+      if (close === void 0) continue;
+      end = close;
+    }
+    result += html.slice(cursor, start);
+    cursor = end;
+    openingTag.lastIndex = end;
+  }
+  return result + html.slice(cursor);
+}
+__name(removeHiddenElements, "removeHiddenElements");
+function isHiddenElement(attributes) {
+  const attribute = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  let match;
+  while (match = attribute.exec(attributes)) {
+    const name = match[1].toLowerCase();
+    const value = (match[2] ?? match[3] ?? match[4] ?? "").trim().toLowerCase();
+    if (name === "aria-hidden" && value === "true") return true;
+    if (name === "hidden" && value !== "until-found") return true;
+  }
+  return false;
+}
+__name(isHiddenElement, "isHiddenElement");
+function isSelfClosingTag(tag) {
+  return /(?:^<[a-zA-Z][\w:-]*|[\s"'])\/>$/.test(tag);
+}
+__name(isSelfClosingTag, "isSelfClosingTag");
+function matchClosingTags(html) {
+  const tags = /<(\/?)([a-zA-Z][\w:-]*)(?:[^>"']|"[^"]*"|'[^']*')*>/g;
+  const open = /* @__PURE__ */ new Map();
+  const closes = /* @__PURE__ */ new Map();
+  let match;
+  while (match = tags.exec(html)) {
+    const name = match[2].toLowerCase();
+    if (match[1]) {
+      const start = open.get(name)?.pop();
+      if (start !== void 0) closes.set(start, match.index + match[0].length);
+    } else if (!VOID_TAGS.has(name) && !isSelfClosingTag(match[0])) {
+      let starts = open.get(name);
+      if (!starts) open.set(name, starts = []);
+      starts.push(match.index);
+    }
+  }
+  return closes;
+}
+__name(matchClosingTags, "matchClosingTags");
+function readStreamedBoundaryInstructions(html) {
+  const boundaries = /* @__PURE__ */ new Map();
+  const placeholders = /* @__PURE__ */ new Map();
+  for (const [, script] of html.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/gi)) {
+    for (const [, kind, first, second] of script.matchAll(
+      /\$R([CRS])\("([^"\\]+)","([^"\\]+)"/g
+    )) {
+      if (kind === "S") placeholders.set(second, first);
+      else boundaries.set(first, second);
+    }
+  }
+  return { boundaries, placeholders };
+}
+__name(readStreamedBoundaryInstructions, "readStreamedBoundaryInstructions");
+function resolveStreamedBoundaries(html, { boundaries, placeholders }) {
+  if (boundaries.size === 0 && placeholders.size === 0) return html;
+  const wanted = /* @__PURE__ */ new Set([...boundaries.values(), ...placeholders.values()]);
+  const segments = /* @__PURE__ */ new Map();
+  const closingTags = matchClosingTags(html);
+  const openingTag = /<([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+  let page = "";
+  let cursor = 0;
+  let match;
+  while (match = openingTag.exec(html)) {
+    const id = /\sid="([^"]*)"/.exec(match[2])?.[1];
+    if (!id || !wanted.has(id) || segments.has(id)) continue;
+    const close = closingTags.get(match.index);
+    if (close === void 0) continue;
+    const contentStart = match.index + match[0].length;
+    segments.set(id, html.slice(contentStart, html.lastIndexOf("<", close - 1)));
+    page += html.slice(cursor, match.index);
+    cursor = close;
+    openingTag.lastIndex = close;
+  }
+  page += html.slice(cursor);
+  const used = /* @__PURE__ */ new Set();
+  const expand = /* @__PURE__ */ __name((fragment) => {
+    const template = /<template\b[^>]*\sid="([^"]+)"[^>]*>\s*<\/template>/gi;
+    let output = "";
+    let position = 0;
+    let found;
+    while (found = template.exec(fragment)) {
+      const id = found[1];
+      const segmentId = boundaries.get(id) ?? placeholders.get(id);
+      const segment = segmentId === void 0 ? void 0 : segments.get(segmentId);
+      if (segment === void 0 || used.has(segmentId)) continue;
+      used.add(segmentId);
+      output += fragment.slice(position, found.index) + expand(segment);
+      position = found.index + found[0].length;
+      if (boundaries.has(id)) {
+        const marker = /<!--(\/?)(?:\$[?!~]?|&)-->/g;
+        marker.lastIndex = position;
+        let depth = 0;
+        let end;
+        while (end = marker.exec(fragment)) {
+          if (!end[1]) depth += 1;
+          else if (depth === 0) break;
+          else depth -= 1;
+        }
+        if (end) position = end.index;
+      }
+      template.lastIndex = position;
+    }
+    return output + fragment.slice(position);
+  }, "expand");
+  return expand(page);
+}
+__name(resolveStreamedBoundaries, "resolveStreamedBoundaries");
+function stripTags(input) {
+  return input.replace(/<[^>]+>/g, "");
+}
+__name(stripTags, "stripTags");
+function escapeHtmlText(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeHtmlText, "escapeHtmlText");
+function decodeHtml(input) {
+  return input.replace(/&(?:nbsp|amp|lt|gt|quot|#39|#(?:x|X)[0-9a-fA-F]+|#[0-9]+);/g, (entity) => {
+    switch (entity) {
+      case "&nbsp;":
+        return " ";
+      case "&amp;":
+        return "&";
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&quot;":
+        return '"';
+      case "&#39;":
+        return "'";
+    }
+    const hexadecimal = entity[2] === "x" || entity[2] === "X";
+    const codePoint = Number.parseInt(entity.slice(hexadecimal ? 3 : 2, -1), hexadecimal ? 16 : 10);
+    return codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 ? "\uFFFD" : String.fromCodePoint(codePoint);
+  });
+}
+__name(decodeHtml, "decodeHtml");
+
+export {
+  createFarmMarkdownViewResponse,
+  FARM_MARKDOWN_CONTENT_TYPE,
+  farmRequestWantsMarkdown,
+  createFarmMarkdownErrorBody,
+  resolveMarkdownConfig,
+  resolveMarkdownMirrorTarget,
+  createMarkdownMirrorResponse,
+  applyMarkdownNegotiationHeaders,
+  htmlToMarkdown,
+  farmAcceptQuality,
+  requestAcceptsMarkdown,
+  getFarmMarkdownMirrorPath,
+  getFarmMarkdownAlternatePath,
+  isFarmMarkdownMirrorExposed,
+  matchesFarmMarkdownRoutePattern,
+  extractFarmPageActions
+};