@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-BBVSJVBZ.cjs

@@ -0,0 +1,600 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/markdown.ts
+var FARM_MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8";
+function farmRequestWantsMarkdown(pathname, accept) {
+  return pathname.toLowerCase().endsWith(".md") || requestAcceptsMarkdown(accept);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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.
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(config.cache, () => ( false)),
+    includeMetadata: _nullishCoalesce(config.includeMetadata, () => ( true))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveMarkdownConfig, "resolveMarkdownConfig");
+function resolveMarkdownMirrorTarget(config, pathname, options = {}) {
+  const hasMarkdownExtension = pathname.toLowerCase().endsWith(".md");
+  if (!_optionalChain([config, 'optionalAccess', _2 => _2.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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveMarkdownMirrorTarget, "resolveMarkdownMirrorTarget");
+async function createMarkdownMirrorResponse(options) {
+  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
+    return null;
+  }
+  const requestUrl = _optionalChain([options, 'access', _3 => _3.requestUrl, 'optionalAccess', _4 => _4.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;
+  const headers = new Headers(options.request.headers);
+  headers.set("accept", "text/html");
+  const pageResponse = await options.renderPage(
+    new Request(pageUrl, {
+      method: "GET",
+      headers
+    })
+  );
+  if (!isHtmlResponse(pageResponse)) {
+    return null;
+  }
+  const html = await pageResponse.text();
+  const markdown = htmlToMarkdown(html, {
+    title: _optionalChain([target, 'access', _5 => _5.route, 'optionalAccess', _6 => _6.title]),
+    includeMetadata: _nullishCoalesce(_optionalChain([options, 'access', _7 => _7.config, 'optionalAccess', _8 => _8.includeMetadata]), () => ( true)),
+    sourcePath: target.pathname
+  });
+  const headersOut = new Headers({
+    "Content-Type": "text/markdown; charset=utf-8",
+    "Content-Location": target.pathname === "/" ? "/index.md" : `${target.pathname}.md`,
+    "X-Farm-Markdown-Route": target.pathname
+  });
+  if (!hasMarkdownExtension) {
+    headersOut.set("Vary", "Accept");
+  }
+  for (const token of _nullishCoalesce(_optionalChain([pageResponse, 'access', _9 => _9.headers, 'access', _10 => _10.get, 'call', _11 => _11("vary"), 'optionalAccess', _12 => _12.split, 'call', _13 => _13(",")]), () => ( []))) {
+    const name = token.trim();
+    if (name && name.toLowerCase() !== "accept") appendHeaderToken(headersOut, "Vary", name);
+  }
+  const pageCacheControl = pageResponse.headers.get("cache-control");
+  const cache = _nullishCoalesce(_nullishCoalesce(_optionalChain([target, 'access', _14 => _14.route, 'optionalAccess', _15 => _15.cache]), () => ( _optionalChain([options, 'access', _16 => _16.config, 'optionalAccess', _17 => _17.cache]))), () => ( false));
+  headersOut.set(
+    "Cache-Control",
+    pageCacheControl && isPrivateCacheControl(pageCacheControl) ? pageCacheControl : createMarkdownCacheHeader(cache)
+  );
+  return new Response(options.request.method === "HEAD" ? null : markdown, {
+    status: pageResponse.status,
+    headers: headersOut
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createMarkdownMirrorResponse, "createMarkdownMirrorResponse");
+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
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _nullishCoalesce(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, "")
+    )
+  );
+  const codeBlocks = [];
+  const setAsideCodeBlock = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (_, code) => {
+    const content = decodeHtml(stripTags(code)).trim();
+    const longestRun = (_nullishCoalesce(content.match(/`+/g), () => ( []))).reduce(
+      (longest, run) => Math.max(longest, run.length),
+      0
+    );
+    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    codeBlocks.push(`${fence}
+${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,
+    setAsideCodeBlock
+  );
+  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 `
+
+${"#".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(/<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) => _nullishCoalesce(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 (metadata.length) {
+      markdown = `${metadata.join("\n\n")}${markdown ? `
+
+${markdown}` : ""}`;
+    }
+  }
+  return `${markdown}
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, htmlToMarkdown, "htmlToMarkdown");
+function normalizeMarkdownRouteInput(input) {
+  if (typeof input === "string") {
+    return {
+      route: normalizeMarkdownRoute(input)
+    };
+  }
+  return {
+    ...input,
+    route: normalizeMarkdownRoute(input.route)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, requestAcceptsMarkdown, "requestAcceptsMarkdown");
+function getMarkdownAlternatePath(pathname) {
+  return pathname === "/" ? "/index.md" : `${pathname}.md`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMarkdownAlternatePath, "getMarkdownAlternatePath");
+function getFarmMarkdownMirrorPath(pathname) {
+  return getMarkdownAlternatePath(pathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmMarkdownMirrorPath, "getFarmMarkdownMirrorPath");
+function getFarmMarkdownAlternatePath(config, pathname) {
+  const target = resolveMarkdownMirrorTarget(config, pathname, { accept: "text/markdown" });
+  return target ? getMarkdownAlternatePath(target.pathname) : null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmMarkdownAlternatePath, "getFarmMarkdownAlternatePath");
+function isFarmMarkdownMirrorExposed(config, pathname) {
+  if (!_optionalChain([config, 'optionalAccess', _18 => _18.enabled])) return false;
+  return config.expose === true || findExposedMarkdownRoute(config, pathname) !== null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmMarkdownMirrorExposed, "isFarmMarkdownMirrorExposed");
+function matchesFarmMarkdownRoutePattern(pattern, pathname) {
+  return routeMatches(pattern, pathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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}`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendHeaderToken, "appendHeaderToken");
+function findExposedMarkdownRoute(config, pathname) {
+  if (config.expose === true) {
+    return null;
+  }
+  return _nullishCoalesce(config.expose.find((route) => routeMatches(route.route, pathname)), () => ( null));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, routeMatches, "routeMatches");
+function isHtmlResponse(response) {
+  const contentType = _nullishCoalesce(response.headers.get("content-type"), () => ( ""));
+  return contentType.includes("text/html");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isHtmlResponse, "isHtmlResponse");
+function isPrivateCacheControl(value) {
+  return value.split(",").some((directive) => {
+    const name = directive.split("=", 1)[0].trim().toLowerCase();
+    return name === "private" || name === "no-store";
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPrivateCacheControl, "isPrivateCacheControl");
+function createMarkdownCacheHeader(cache) {
+  if (cache === false || cache <= 0) {
+    return "no-store";
+  }
+  return `public, max-age=${cache}, s-maxage=${cache}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createMarkdownCacheHeader, "createMarkdownCacheHeader");
+function extractHtmlTitle(html) {
+  const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? decodeHtml(stripTags(match[1])).trim() : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, extractHtmlTitle, "extractHtmlTitle");
+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 _nullishCoalesce(extractFirstElementContent(body, ["main", "article"]), () => ( body));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, extractFirstElementContent, "extractFirstElementContent");
+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) => {
+    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, " ");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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)) {
+      _nullishCoalesce(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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = (_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isHiddenElement, "isHiddenElement");
+function isSelfClosingTag(tag) {
+  return /(?:^<[a-zA-Z][\w:-]*|[\s"'])\/>$/.test(tag);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _optionalChain([open, 'access', _19 => _19.get, 'call', _20 => _20(name), 'optionalAccess', _21 => _21.pop, 'call', _22 => _22()]);
+      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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _optionalChain([/\sid="([^"]*)"/, 'access', _23 => _23.exec, 'call', _24 => _24(match[2]), 'optionalAccess', _25 => _25[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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 = _nullishCoalesce(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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveStreamedBoundaries, "resolveStreamedBoundaries");
+function stripTags(input) {
+  return input.replace(/<[^>]+>/g, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, stripTags, "stripTags");
+function escapeHtmlText(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeHtml, "decodeHtml");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_MARKDOWN_CONTENT_TYPE = FARM_MARKDOWN_CONTENT_TYPE; exports.farmRequestWantsMarkdown = farmRequestWantsMarkdown; exports.createFarmMarkdownErrorBody = createFarmMarkdownErrorBody; exports.resolveMarkdownConfig = resolveMarkdownConfig; exports.resolveMarkdownMirrorTarget = resolveMarkdownMirrorTarget; exports.createMarkdownMirrorResponse = createMarkdownMirrorResponse; exports.applyMarkdownNegotiationHeaders = applyMarkdownNegotiationHeaders; exports.htmlToMarkdown = htmlToMarkdown; exports.farmAcceptQuality = farmAcceptQuality; exports.requestAcceptsMarkdown = requestAcceptsMarkdown; exports.getFarmMarkdownMirrorPath = getFarmMarkdownMirrorPath; exports.getFarmMarkdownAlternatePath = getFarmMarkdownAlternatePath; exports.isFarmMarkdownMirrorExposed = isFarmMarkdownMirrorExposed; exports.matchesFarmMarkdownRoutePattern = matchesFarmMarkdownRoutePattern;