webforai 2.1.1 → 3.0.0

package/dist/cjs/html-to-markdown.js

@@ -18,18 +18,55 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var html_to_markdown_exports = {};
 __export(html_to_markdown_exports, {
-  htmlToMarkdown: () => htmlToMarkdown
+  htmlToMarkdown: () => htmlToMarkdown,
+  htmlToMarkdownWithMetadata: () => htmlToMarkdownWithMetadata
 });
 module.exports = __toCommonJS(html_to_markdown_exports);
+var import_hast_util_from_html = require("hast-util-from-html");
 var import_html_to_mdast = require("./html-to-mdast");
 var import_mdast_to_markdown = require("./mdast-to-markdown");
-const htmlToMarkdown = (htmlOrHast, options) => {
-  const { baseUrl, formatting: toMarkdownOptions, ...toMdastOptions } = options || {};
-  const mdast = (0, import_html_to_mdast.htmlToMdast)(htmlOrHast, toMdastOptions);
-  const markdown = (0, import_mdast_to_markdown.mdastToMarkdown)(mdast, { baseUrl, ...toMarkdownOptions });
-  return markdown;
+var import_metadata = require("./metadata");
+var import_hast_utils = require("./utils/hast-utils");
+const htmlToMarkdownWithMetadata = (htmlOrHast, options) => {
+  const { baseUrl, frontmatter, title, formatting: toMarkdownOptions, ...toMdastOptions } = options || {};
+  const hast = typeof htmlOrHast === "string" ? (0, import_hast_util_from_html.fromHtml)(htmlOrHast, { fragment: true }) : htmlOrHast;
+  const isOwned = typeof htmlOrHast === "string";
+  const declaredLang = typeof htmlOrHast === "string" ? (0, import_hast_utils.getLangFromStr)(htmlOrHast) : void 0;
+  const metadata = (0, import_metadata.extractMetadata)(hast);
+  if (declaredLang && !metadata.lang) {
+    metadata.lang = declaredLang;
+  }
+  const mdast = (0, import_html_to_mdast.htmlToMdast)(hast, {
+    ...toMdastOptions,
+    owned: isOwned,
+    lang: toMdastOptions.lang ?? metadata.lang,
+    url: toMdastOptions.url ?? metadata.canonicalUrl
+  });
+  const body = (0, import_mdast_to_markdown.mdastToMarkdown)(mdast, { baseUrl, ...toMarkdownOptions });
+  const titled = title === false ? body : withTitle(body, metadata.title);
+  const markdown = frontmatter ? `${(0, import_metadata.toFrontmatter)(metadata)}${titled}` : titled;
+  return { markdown, metadata };
+};
+const TITLE_LOOKAHEAD = 400;
+const withTitle = (body, title) => {
+  if (!title) {
+    return body;
+  }
+  const opening = body.slice(0, TITLE_LOOKAHEAD);
+  if (/^#\s+\S/m.test(opening)) {
+    return body;
+  }
+  if (normalizeForCompare(opening).includes(normalizeForCompare(title))) {
+    return body;
+  }
+  return `# ${title}
+
+${body}`;
 };
+const normalizeForCompare = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+const htmlToMarkdown = (htmlOrHast, options) => htmlToMarkdownWithMetadata(htmlOrHast, options).markdown;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  htmlToMarkdown
+  htmlToMarkdown,
+  htmlToMarkdownWithMetadata
 });

package/dist/cjs/html-to-mdast.js

@@ -30,18 +30,26 @@ var import_custom_code_handler = require("./mdast-handlers/custom-code-handler")
 var import_custom_div_handler = require("./mdast-handlers/custom-div-handler");
 var import_custom_img_handler = require("./mdast-handlers/custom-img-handler");
 var import_custom_table_handler = require("./mdast-handlers/custom-table-handler");
+var import_definition_list_handler = require("./mdast-handlers/definition-list-handler");
 var import_math_handler = require("./mdast-handlers/math-handler");
+var import_sup_sub_handler = require("./mdast-handlers/sup-sub-handler");
+var import_normalize = require("./normalize");
 var import_hast_utils = require("./utils/hast-utils");
 const htmlToMdast = (htmlOrHast, options) => {
   const { extractors, url: defaultUrl, lang: defaultLang } = options || {};
   const [lang, hast] = typeof htmlOrHast === "string" ? [defaultLang || (0, import_hast_utils.getLangFromStr)(htmlOrHast), (0, import_hast_util_from_html.fromHtml)(htmlOrHast, { fragment: true })] : [defaultLang || (0, import_hast_utils.getLangFromHast)(htmlOrHast), htmlOrHast];
+  const isOwned = typeof htmlOrHast === "string" || (options?.owned ?? false);
   const url = defaultUrl || (0, import_hast_utils.getUrlFromHast)(hast);
-  const extractedHast = (0, import_extractors.pipeExtractors)({ hast, lang, url }, extractors);
+  const extractedHast = (0, import_extractors.pipeExtractors)({ hast, lang, url, owned: isOwned }, extractors);
+  (0, import_normalize.normalizeHast)(extractedHast, options?.normalize);
   const mdast = (0, import_hast_util_to_mdast.toMdast)(extractedHast, {
     handlers: {
       math: import_math_handler.mathHandler,
       div: import_custom_div_handler.customDivHandler,
       pre: import_custom_code_handler.customCodeHandler,
+      dl: import_definition_list_handler.definitionListHandler,
+      sup: (0, import_sup_sub_handler.supSubHandler)("sup"),
+      sub: (0, import_sup_sub_handler.supSubHandler)("sub"),
       a: (0, import_custom_a_handler.customAHandler)({ asText: options?.linkAsText }),
       img: (0, import_custom_img_handler.customImgHandler)({ hideImage: options?.hideImage }),
       table: (0, import_custom_table_handler.customTableHandler)({ asText: options?.tableAsText })

package/dist/cjs/index.js

@@ -18,13 +18,26 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  BUILTIN_ADAPTERS: () => import_adapters.BUILTIN_ADAPTERS,
+  adapterById: () => import_adapters.adapterById,
+  autoExtractor: () => import_extractors.autoExtractor,
+  buildPageSignature: () => import_adapters.buildPageSignature,
+  createAutoExtractor: () => import_extractors.createAutoExtractor,
+  defineSelectorAdapter: () => import_adapters.defineSelectorAdapter,
+  extractMetadata: () => import_metadata.extractMetadata,
   htmlToMarkdown: () => import_html_to_markdown.htmlToMarkdown,
+  htmlToMarkdownWithMetadata: () => import_html_to_markdown.htmlToMarkdownWithMetadata,
   htmlToMdast: () => import_html_to_mdast.htmlToMdast,
   mdastSplitter: () => import_md_splitter.mdastSplitter,
   mdastToMarkdown: () => import_mdast_to_markdown.mdastToMarkdown,
   minimalFilter: () => import_extractors.minimalFilter,
+  normalizeHast: () => import_normalize.normalizeHast,
   pipeExtractors: () => import_extractors.pipeExtractors,
-  takumiExtractor: () => import_extractors.takumiExtractor
+  resolveAdapter: () => import_adapters.resolveAdapter,
+  runAdapters: () => import_adapters.runAdapters,
+  takumiExtractor: () => import_extractors.takumiExtractor,
+  toFrontmatter: () => import_metadata.toFrontmatter,
+  youtubeCaptionTracks: () => import_adapters.youtubeCaptionTracks
 });
 module.exports = __toCommonJS(src_exports);
 var import_html_to_markdown = require("./html-to-markdown");
@@ -32,13 +45,29 @@ var import_md_splitter = require("./md-splitter");
 var import_html_to_mdast = require("./html-to-mdast");
 var import_mdast_to_markdown = require("./mdast-to-markdown");
 var import_extractors = require("./extractors");
+var import_adapters = require("./adapters");
+var import_metadata = require("./metadata");
+var import_normalize = require("./normalize");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BUILTIN_ADAPTERS,
+  adapterById,
+  autoExtractor,
+  buildPageSignature,
+  createAutoExtractor,
+  defineSelectorAdapter,
+  extractMetadata,
   htmlToMarkdown,
+  htmlToMarkdownWithMetadata,
   htmlToMdast,
   mdastSplitter,
   mdastToMarkdown,
   minimalFilter,
+  normalizeHast,
   pipeExtractors,
-  takumiExtractor
+  resolveAdapter,
+  runAdapters,
+  takumiExtractor,
+  toFrontmatter,
+  youtubeCaptionTracks
 });

package/dist/cjs/mdast-handlers/custom-a-handler.js

@@ -23,21 +23,37 @@ __export(custom_a_handler_exports, {
 module.exports = __toCommonJS(custom_a_handler_exports);
 var import_hast_util_to_mdast = require("hast-util-to-mdast");
 var import_hast_util_to_string = require("hast-util-to-string");
+var import_hast_fast = require("../utils/hast-fast");
+const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:", "ftp:", "ftps:"]);
+const isFollowableHref = (href) => {
+  const trimmed = href?.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const scheme = trimmed.match(/^[a-z][a-z0-9+.-]*:/i)?.[0];
+  if (!scheme) {
+    return true;
+  }
+  return ALLOWED_SCHEMES.has(scheme.toLowerCase());
+};
 const customAHandler = (options) => (state, node) => {
-  if (options?.asText) {
+  const asPlainText = () => {
     const text = (0, import_hast_util_to_string.toString)(node);
-    if (3 >= text.length) {
+    if (text.length === 0) {
       return void 0;
     }
-    const link2 = { type: "text", value: text };
-    state.patch(node, link2);
-    return link2;
+    const result = { type: "text", value: text };
+    state.patch(node, result);
+    return result;
+  };
+  if (options?.asText) {
+    return (0, import_hast_util_to_string.toString)(node).length <= 3 ? void 0 : asPlainText();
   }
-  const link = import_hast_util_to_mdast.defaultHandlers.a(state, node);
-  if (link.children.length > 0) {
-    return link;
+  if (!isFollowableHref((0, import_hast_fast.stringProperty)(node, "href"))) {
+    return asPlainText();
   }
-  return void 0;
+  const link = import_hast_util_to_mdast.defaultHandlers.a(state, node);
+  return link.children.length > 0 ? link : void 0;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/mdast-handlers/custom-img-handler.js

@@ -22,11 +22,33 @@ __export(custom_img_handler_exports, {
 });
 module.exports = __toCommonJS(custom_img_handler_exports);
 var import_hast_util_to_mdast = require("hast-util-to-mdast");
+var import_hast_fast = require("../utils/hast-fast");
+const MAX_DATA_URL_LENGTH = 256;
+const hasNoUsableSource = (node) => {
+  const src = (0, import_hast_fast.stringProperty)(node, "src")?.trim();
+  if (!src) {
+    return true;
+  }
+  if (src.startsWith("data:")) {
+    return src.length > MAX_DATA_URL_LENGTH;
+  }
+  return false;
+};
 const customImgHandler = (options) => (state, node) => {
   if (options?.hideImage) {
     return void 0;
   }
-  return import_hast_util_to_mdast.defaultHandlers.image(state, node);
+  if (hasNoUsableSource(node)) {
+    return void 0;
+  }
+  const image = import_hast_util_to_mdast.defaultHandlers.image(state, node);
+  if (!image.alt) {
+    const title = (0, import_hast_fast.stringProperty)(node, "title");
+    if (title) {
+      image.alt = title;
+    }
+  }
+  return image;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/mdast-handlers/custom-table-handler.js

@@ -23,12 +23,28 @@ __export(custom_table_handler_exports, {
 module.exports = __toCommonJS(custom_table_handler_exports);
 var import_hast_util_to_mdast = require("hast-util-to-mdast");
 var import_hast_util_to_text = require("hast-util-to-text");
+var import_hast_fast = require("../utils/hast-fast");
+const MAX_SPAN = 1e3;
+const clampSpans = (node) => {
+  (0, import_hast_fast.walk)(node, (candidate) => {
+    if (!(0, import_hast_fast.isElement)(candidate) || candidate.tagName !== "td" && candidate.tagName !== "th") {
+      return;
+    }
+    for (const attribute of ["colSpan", "rowSpan"]) {
+      const span = (0, import_hast_fast.numericProperty)(candidate, attribute);
+      if (span !== void 0 && span > MAX_SPAN) {
+        candidate.properties[attribute] = MAX_SPAN;
+      }
+    }
+  });
+};
 const customTableHandler = (options) => (state, node) => {
   if (options?.asText) {
     const paragraph = { type: "paragraph", children: [{ type: "text", value: (0, import_hast_util_to_text.toText)(node) }] };
     state.patch(node, paragraph);
     return paragraph;
   }
+  clampSpans(node);
   return import_hast_util_to_mdast.defaultHandlers.table(state, node);
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/mdast-handlers/definition-list-handler.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var definition_list_handler_exports = {};
+__export(definition_list_handler_exports, {
+  definitionListHandler: () => definitionListHandler
+});
+module.exports = __toCommonJS(definition_list_handler_exports);
+const hoistBoundaryWhitespace = (nodes) => {
+  const result = [];
+  for (const node of nodes) {
+    if (node.type !== "emphasis" && node.type !== "strong") {
+      result.push(node);
+      continue;
+    }
+    node.children = hoistBoundaryWhitespace(node.children);
+    const first = node.children[0];
+    if (first?.type === "text" && /^\s/.test(first.value)) {
+      result.push({ type: "text", value: " " });
+      first.value = first.value.replace(/^\s+/, "");
+    }
+    let trailing = false;
+    const last = node.children[node.children.length - 1];
+    if (last?.type === "text" && /\s$/.test(last.value)) {
+      last.value = last.value.replace(/\s+$/, "");
+      trailing = true;
+    }
+    node.children = node.children.filter((child) => !(child.type === "text" && child.value.length === 0));
+    if (node.children.length > 0) {
+      result.push(node);
+    }
+    if (trailing) {
+      result.push({ type: "text", value: " " });
+    }
+  }
+  return result;
+};
+const definitionListHandler = (state, node) => {
+  const items = [];
+  let current;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const heading = {
+      type: "paragraph",
+      children: current.term.length > 0 ? [{ type: "strong", children: current.term }] : []
+    };
+    items.push({ type: "listItem", spread: false, children: [heading, ...current.definitions] });
+    current = void 0;
+  };
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    const element = child;
+    if (element.tagName === "dt") {
+      if (current && current.definitions.length > 0) {
+        flush();
+      }
+      const phrasing = hoistBoundaryWhitespace(state.all(element));
+      current = current ? { term: [...current.term, { type: "text", value: ", " }, ...phrasing], definitions: [] } : { term: phrasing, definitions: [] };
+      continue;
+    }
+    if (element.tagName === "dd") {
+      if (!current) {
+        current = { term: [], definitions: [] };
+      }
+      const content = state.toFlow(state.all(element));
+      current.definitions.push(...content);
+    }
+  }
+  flush();
+  if (items.length === 0) {
+    return void 0;
+  }
+  const result = { type: "list", ordered: false, spread: false, children: items };
+  state.patch(node, result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  definitionListHandler
+});

package/dist/cjs/mdast-handlers/math-handler.js

@@ -23,10 +23,19 @@ __export(math_handler_exports, {
 module.exports = __toCommonJS(math_handler_exports);
 var import_hast_util_to_html = require("hast-util-to-html");
 var import_mathml_to_latex = require("mathml-to-latex");
+var import_hast_fast = require("../utils/hast-fast");
+const readAnnotation = (node) => {
+  const alttext = (0, import_hast_fast.stringProperty)(node, "alttext");
+  if (!alttext) {
+    return void 0;
+  }
+  const unwrapped = alttext.trim().replace(/^\{\\displaystyle\s*([\s\S]*)\}$/, "$1").trim();
+  return unwrapped.length > 0 ? unwrapped : void 0;
+};
+const isDisplayMath = (node) => (0, import_hast_fast.stringProperty)(node, "display") === "block";
 const mathHandler = (state, node) => {
-  const mathMl = (0, import_hast_util_to_html.toHtml)(node);
-  const latex = import_mathml_to_latex.MathMLToLaTeX.convert(mathMl);
-  const result = { type: "inlineMath", value: latex };
+  const latex = readAnnotation(node) ?? import_mathml_to_latex.MathMLToLaTeX.convert((0, import_hast_util_to_html.toHtml)(node));
+  const result = isDisplayMath(node) ? { type: "math", value: latex, meta: null } : { type: "inlineMath", value: latex };
   state.patch(node, result);
   return result;
 };

package/dist/cjs/mdast-handlers/sup-sub-handler.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sup_sub_handler_exports = {};
+__export(sup_sub_handler_exports, {
+  supSubHandler: () => supSubHandler
+});
+module.exports = __toCommonJS(sup_sub_handler_exports);
+var import_hast_util_to_string = require("hast-util-to-string");
+const MAX_ANNOTATION_LENGTH = 32;
+const supSubHandler = (tagName) => (state, node) => {
+  const inner = (0, import_hast_util_to_string.toString)(node).trim();
+  if (inner.length === 0 || inner.length > MAX_ANNOTATION_LENGTH) {
+    return state.all(node);
+  }
+  const escaped = inner.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const result = { type: "html", value: `<${tagName}>${escaped}</${tagName}>` };
+  state.patch(node, result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  supSubHandler
+});

package/dist/cjs/metadata/index.js

@@ -0,0 +1,223 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metadata_exports = {};
+__export(metadata_exports, {
+  extractMetadata: () => extractMetadata,
+  readJsonLd: () => readJsonLd,
+  toFrontmatter: () => toFrontmatter
+});
+module.exports = __toCommonJS(metadata_exports);
+var import_hast_fast = require("../utils/hast-fast");
+const readMetaTags = (tree) => {
+  const tags = /* @__PURE__ */ new Map();
+  for (const meta of (0, import_hast_fast.collectElements)(tree, (element) => element.tagName === "meta")) {
+    const key = (0, import_hast_fast.stringProperty)(meta, "property") ?? (0, import_hast_fast.stringProperty)(meta, "name") ?? (0, import_hast_fast.stringProperty)(meta, "itemprop");
+    const content = (0, import_hast_fast.stringProperty)(meta, "content");
+    if (!(key && content)) {
+      continue;
+    }
+    const normalized = key.toLowerCase();
+    if (!tags.has(normalized)) {
+      tags.set(normalized, content);
+    }
+  }
+  return tags;
+};
+const readJsonLd = (tree) => {
+  const entries = [];
+  for (const script of (0, import_hast_fast.collectElements)(tree, (element) => element.tagName === "script")) {
+    const type = (0, import_hast_fast.stringProperty)(script, "type");
+    if (type?.toLowerCase() !== "application/ld+json") {
+      continue;
+    }
+    const source = script.children.map((child) => child.type === "text" ? child.value : "").join("").trim();
+    if (source.length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(source);
+    } catch {
+      continue;
+    }
+    for (const entry of flattenJsonLd(parsed)) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+};
+const flattenJsonLd = (value) => {
+  if (Array.isArray(value)) {
+    return value.flatMap(flattenJsonLd);
+  }
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  const record = value;
+  const graph = record["@graph"];
+  if (graph) {
+    return flattenJsonLd(graph);
+  }
+  return [record];
+};
+const ARTICLE_TYPES = /* @__PURE__ */ new Set([
+  "article",
+  "newsarticle",
+  "blogposting",
+  "techarticle",
+  "scholarlyarticle",
+  "report",
+  "webpage"
+]);
+const jsonLdType = (entry) => {
+  const type = entry["@type"];
+  if (typeof type === "string") {
+    return [type.toLowerCase()];
+  }
+  if (Array.isArray(type)) {
+    return type.filter((value) => typeof value === "string").map((value) => value.toLowerCase());
+  }
+  return [];
+};
+const readName = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const name = readName(entry);
+      if (name) {
+        return name;
+      }
+    }
+    return void 0;
+  }
+  if (typeof value === "object" && value !== null) {
+    const name = value.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  return void 0;
+};
+const asString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+const MAX_TITLE_LENGTH = 160;
+const asTitle = (value) => {
+  const cleaned = clean(value);
+  return cleaned && cleaned.length <= MAX_TITLE_LENGTH ? cleaned : void 0;
+};
+const clean = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+const documentTitle = (tree) => {
+  const title = (0, import_hast_fast.findElement)(tree, (element) => element.tagName === "title");
+  if (!title) {
+    return void 0;
+  }
+  return title.children.map((child) => child.type === "text" ? child.value : "").join("");
+};
+const firstHeading = (tree) => {
+  const heading = (0, import_hast_fast.findElement)(tree, (element) => element.tagName === "h1");
+  if (!heading) {
+    return void 0;
+  }
+  let text = "";
+  (0, import_hast_fast.walk)(heading, (node) => {
+    if (node.type === "text") {
+      text += node.value;
+    }
+  });
+  return text;
+};
+const linkHref = (tree, rel) => {
+  const link = (0, import_hast_fast.findElement)(
+    tree,
+    (element) => element.tagName === "link" && ((0, import_hast_fast.stringProperty)(element, "rel") ?? "").toLowerCase().includes(rel)
+  );
+  return link ? (0, import_hast_fast.stringProperty)(link, "href") : void 0;
+};
+const documentLang = (tree) => {
+  const html = (0, import_hast_fast.findElement)(tree, (element) => element.tagName === "html");
+  if (html) {
+    const declared = (0, import_hast_fast.stringProperty)(html, "lang") ?? (0, import_hast_fast.stringProperty)(html, "xml:lang");
+    if (declared) {
+      return declared;
+    }
+  }
+  if ((0, import_hast_fast.isElement)(tree)) {
+    const own = (0, import_hast_fast.stringProperty)(tree, "lang");
+    if (own) {
+      return own;
+    }
+  }
+  const tagged = (0, import_hast_fast.findElement)(tree, (element) => Boolean((0, import_hast_fast.stringProperty)(element, "lang")));
+  return tagged ? (0, import_hast_fast.stringProperty)(tagged, "lang") : void 0;
+};
+const extractMetadata = (tree) => {
+  const meta = readMetaTags(tree);
+  const jsonLd = readJsonLd(tree);
+  const article = jsonLd.find((entry) => jsonLdType(entry).some((type) => ARTICLE_TYPES.has(type))) ?? jsonLd[0];
+  const get = (...keys) => {
+    for (const key of keys) {
+      const value = meta.get(key);
+      if (value) {
+        return value;
+      }
+    }
+    return void 0;
+  };
+  const title = asTitle(get("og:title", "twitter:title")) ?? asTitle(asString(article?.headline)) ?? asTitle(asString(article?.name)) ?? asTitle(documentTitle(tree)) ?? asTitle(firstHeading(tree));
+  return {
+    title,
+    description: clean(get("og:description", "twitter:description", "description")) ?? clean(asString(article?.description)),
+    author: clean(readName(article?.author)) ?? clean(get("author", "article:author", "twitter:creator")),
+    published: clean(asString(article?.datePublished)) ?? clean(get("article:published_time", "date", "pubdate")),
+    modified: clean(asString(article?.dateModified)) ?? clean(get("article:modified_time", "og:updated_time")),
+    siteName: clean(get("og:site_name", "application-name")) ?? clean(readName(article?.publisher)),
+    canonicalUrl: clean(linkHref(tree, "canonical")) ?? clean(get("og:url", "twitter:url")),
+    lang: clean(documentLang(tree)),
+    image: clean(get("og:image", "twitter:image", "twitter:image:src")),
+    type: clean(get("og:type"))
+  };
+};
+const yamlString = (value) => `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+const toFrontmatter = (metadata) => {
+  const lines = [];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (typeof value === "string" && value.length > 0) {
+      lines.push(`${key}: ${yamlString(value)}`);
+    }
+  }
+  if (lines.length === 0) {
+    return "";
+  }
+  return `---
+${lines.join("\n")}
+---
+
+`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractMetadata,
+  readJsonLd,
+  toFrontmatter
+});