webforai 0.0.17 → 0.0.19

package/dist/cjs/extract-hast.js

@@ -0,0 +1,45 @@
+"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 extract_hast_exports = {};
+__export(extract_hast_exports, {
+  extractHast: () => extractHast
+});
+module.exports = __toCommonJS(extract_hast_exports);
+var import_hast_util_select = require("hast-util-select");
+var import_unist_util_remove = require("unist-util-remove");
+const extractHast = (hast) => {
+  const removeSelectors = ["header", "footer", "nav", "speechify-ignore"];
+  for (const selector of removeSelectors) {
+    const matchedNodes = (0, import_hast_util_select.selectAll)(selector, hast);
+    for (const node of matchedNodes) {
+      (0, import_unist_util_remove.remove)(hast, { type: node.type, tagName: node.tagName });
+    }
+  }
+  const selectors = ["article", "div#article", "main", "div.container"];
+  for (const selector of selectors) {
+    const element = (0, import_hast_util_select.select)(selector, hast);
+    if (element)
+      return element;
+  }
+  return hast;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractHast
+});

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

@@ -0,0 +1,34 @@
+"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 html_to_markdown_exports = {};
+__export(html_to_markdown_exports, {
+  htmlToMarkdown: () => htmlToMarkdown
+});
+module.exports = __toCommonJS(html_to_markdown_exports);
+var import_html_to_mdast = require("./html-to-mdast");
+var import_mdast_to_markdown = require("./mdast-to-markdown");
+const htmlToMarkdown = (html, options) => {
+  const mdast = (0, import_html_to_mdast.htmlToMdast)(html, options);
+  const markdown = (0, import_mdast_to_markdown.mdastToMarkdown)(mdast, options);
+  return markdown;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  htmlToMarkdown
+});

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

@@ -0,0 +1,41 @@
+"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 html_to_mdast_exports = {};
+__export(html_to_mdast_exports, {
+  htmlToMdast: () => htmlToMdast
+});
+module.exports = __toCommonJS(html_to_mdast_exports);
+var import_hast_util_from_html = require("hast-util-from-html");
+var import_hast_util_to_mdast = require("hast-util-to-mdast");
+var import_extract_hast = require("./extract-hast");
+var import_custom_div_handler = require("./mdast-handlers/custom-div-handler");
+var import_math_handler = require("./mdast-handlers/math-handler");
+const htmlToMdast = (html, options) => {
+  const hast = (0, import_hast_util_from_html.fromHtml)(html, { fragment: true });
+  const extractedHast = options?.extractHast ? options.extractHast(hast) : (0, import_extract_hast.extractHast)(hast);
+  const mdast = (0, import_hast_util_to_mdast.toMdast)(extractedHast, {
+    handlers: { div: import_custom_div_handler.customDivHandler, math: import_math_handler.mathHandler, br: () => {
+    } }
+  });
+  return mdast;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  htmlToMdast
+});

package/dist/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./html-to-markdown"), module.exports);
+__reExport(src_exports, require("./md-splitter"), module.exports);
+__reExport(src_exports, require("./html-to-mdast"), module.exports);
+__reExport(src_exports, require("./mdast-to-markdown"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./html-to-markdown"),
+  ...require("./md-splitter"),
+  ...require("./html-to-mdast"),
+  ...require("./mdast-to-markdown")
+});

package/dist/cjs/link-replacer.js

@@ -0,0 +1,35 @@
+"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 link_replacer_exports = {};
+__export(link_replacer_exports, {
+  linkReplacer: () => linkReplacer
+});
+module.exports = __toCommonJS(link_replacer_exports);
+const linkReplacer = (markdown, link) => {
+  const regex = /(!?\[.*?\]\()(.+?)(\))/g;
+  return markdown.replace(regex, (match, pre, thisUrl, post) => {
+    if (thisUrl.startsWith("http") || thisUrl.startsWith("#"))
+      return match;
+    return `${pre}${new URL(thisUrl, link).href}${post}`;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  linkReplacer
+});

package/dist/cjs/loaders/playwright.js

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwright_exports = {};
+__export(playwright_exports, {
+  loadHtml: () => loadHtml
+});
+module.exports = __toCommonJS(playwright_exports);
+var playwright = __toESM(require("playwright"), 1);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const loadHtml = async (url, context) => {
+  let _browser = null;
+  let _context;
+  if (!context) {
+    _browser = await playwright.chromium.launch();
+    _context = await _browser.newContext();
+  } else {
+    _context = context;
+  }
+  const page = await _context.newPage();
+  await page.goto(url);
+  await Promise.race([page.waitForLoadState("networkidle"), sleep(1e4)]);
+  const html = await page.content();
+  await page.close();
+  if (_browser)
+    await _browser.close();
+  return html;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadHtml
+});

package/dist/cjs/md-splitter.js

@@ -0,0 +1,54 @@
+"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 md_splitter_exports = {};
+__export(md_splitter_exports, {
+  mdastSplitter: () => mdastSplitter
+});
+module.exports = __toCommonJS(md_splitter_exports);
+var import_mdast_to_markdown = require("./mdast-to-markdown");
+var import_common = require("./utils/common");
+var import_mdast_utils = require("./utils/mdast-utils");
+const PRIORITY_SPLITTERS = ["h1", "h2", "h3", "h4", "h5", "h6", "list", "table", "code"];
+const getSplitterGenerator = function* () {
+  for (const splitter of PRIORITY_SPLITTERS)
+    yield splitter;
+};
+const _mdastSplitter = async (contents, checker, splitterGenerator) => {
+  const markdown = (0, import_mdast_to_markdown.mdastToMarkdown)((0, import_mdast_utils.warpRoot)(contents));
+  if (await checker(markdown) || 3 > contents.length)
+    return [contents];
+  const splitter = splitterGenerator.next().value;
+  const chunked = splitter ? contents.reduce((acc, content) => {
+    if ((0, import_mdast_utils.internalType)(content) === splitter || acc.length === 0) {
+      acc.push([content]);
+      return acc;
+    }
+    acc[acc.length - 1].push(content);
+    return acc;
+  }, []) : (0, import_common.chunk)(contents, 3);
+  const splitting = chunked.map((chunk2) => _mdastSplitter(chunk2, checker, splitterGenerator));
+  return Promise.all(splitting).then((chunks) => chunks.flat());
+};
+const mdastSplitter = async (mdast, checker, options) => {
+  return _mdastSplitter((0, import_mdast_utils.unwarpRoot)(mdast), checker, getSplitterGenerator());
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mdastSplitter
+});

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

@@ -0,0 +1,65 @@
+"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 custom_div_handler_exports = {};
+__export(custom_div_handler_exports, {
+  customDivHandler: () => customDivHandler
+});
+module.exports = __toCommonJS(custom_div_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_trim_trailing_lines = require("trim-trailing-lines");
+const customDivHandler = (state, node) => {
+  const classNames = Array.isArray(node.properties.className) ? node.properties.className : [];
+  let highlightLanguage;
+  for (const className of classNames) {
+    if (String(className) === "highlight-text-html-basic") {
+      highlightLanguage = "html";
+      break;
+    } else if (String(className).includes("highlight-source-")) {
+      highlightLanguage = String(className).slice("highlight-source-".length);
+      break;
+    } else if (String(className).includes("language-")) {
+      highlightLanguage = String(className).slice("language-".length);
+      break;
+    } else if (String(className).includes("code-block_wrapper")) {
+      const text = (0, import_hast_util_to_text.toText)(node);
+      if (!text.includes("."))
+        break;
+      const lang = (0, import_hast_util_to_text.toText)(node).split("\n")[0].split(".").slice(-1)[0];
+      highlightLanguage = lang;
+      break;
+    }
+  }
+  if (highlightLanguage !== void 0) {
+    const code = node.children.find((child) => child.type === "element" && child.tagName === "pre") || node;
+    const result = {
+      type: "code",
+      lang: highlightLanguage,
+      meta: null,
+      value: (0, import_trim_trailing_lines.trimTrailingLines)((0, import_hast_util_to_text.toText)(code)).trim()
+    };
+    state.patch(node, result);
+    return result;
+  }
+  return import_hast_util_to_mdast.defaultHandlers.div(state, node);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customDivHandler
+});

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

@@ -0,0 +1,36 @@
+"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 math_handler_exports = {};
+__export(math_handler_exports, {
+  mathHandler: () => mathHandler
+});
+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");
+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 };
+  state.patch(node, result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mathHandler
+});

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

@@ -0,0 +1,40 @@
+"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 mdast_to_markdown_exports = {};
+__export(mdast_to_markdown_exports, {
+  mdastToMarkdown: () => mdastToMarkdown
+});
+module.exports = __toCommonJS(mdast_to_markdown_exports);
+var import_mdast_util_gfm = require("mdast-util-gfm");
+var import_mdast_util_math = require("mdast-util-math");
+var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
+var import_link_replacer = require("./link-replacer");
+var import_mdast_utils = require("./utils/mdast-utils");
+const mdastToMarkdown = (mdast, options) => {
+  let markdown = (0, import_mdast_util_to_markdown.toMarkdown)((0, import_mdast_utils.warpRoot)(mdast), {
+    extensions: [(0, import_mdast_util_gfm.gfmToMarkdown)(), (0, import_mdast_util_math.mathToMarkdown)()]
+  });
+  if (options?.solveLinks)
+    markdown = (0, import_link_replacer.linkReplacer)(markdown, options.solveLinks);
+  return markdown;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mdastToMarkdown
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/utils/common.js

@@ -0,0 +1,36 @@
+"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 common_exports = {};
+__export(common_exports, {
+  chunk: () => chunk
+});
+module.exports = __toCommonJS(common_exports);
+const chunk = (array, size) => {
+  return array.reduce((acc, _, index) => {
+    if (index % size === 0) {
+      acc.push(array.slice(index, index + size));
+      return acc;
+    }
+    return acc;
+  }, []);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunk
+});

package/dist/cjs/utils/mdast-utils.js

@@ -0,0 +1,46 @@
+"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 mdast_utils_exports = {};
+__export(mdast_utils_exports, {
+  internalType: () => internalType,
+  unwarpRoot: () => unwarpRoot,
+  warpRoot: () => warpRoot
+});
+module.exports = __toCommonJS(mdast_utils_exports);
+const unwarpRoot = (mdast) => {
+  if (mdast.type === "root")
+    return mdast.children;
+  return [mdast];
+};
+const warpRoot = (mdast) => {
+  if (Array.isArray(mdast))
+    return { type: "root", children: mdast };
+  return mdast;
+};
+const internalType = (content) => {
+  if (content.type === "heading")
+    return `h${content.depth}`;
+  return content.type;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  internalType,
+  unwarpRoot,
+  warpRoot
+});

package/dist/extract-hast.js

@@ -1,19 +1,22 @@
+// src/extract-hast.ts
 import { select, selectAll } from "hast-util-select";
 import { remove } from "unist-util-remove";
-export const extractHast = (hast) => {
-    const removeSelectors = ["header", "footer", "nav", "speechify-ignore"];
-    for (const selector of removeSelectors) {
-        const matchedNodes = selectAll(selector, hast);
-        for (const node of matchedNodes) {
-            remove(hast, { type: node.type, tagName: node.tagName });
-        }
+var extractHast = (hast) => {
+  const removeSelectors = ["header", "footer", "nav", "speechify-ignore"];
+  for (const selector of removeSelectors) {
+    const matchedNodes = selectAll(selector, hast);
+    for (const node of matchedNodes) {
+      remove(hast, { type: node.type, tagName: node.tagName });
     }
-    const selectors = ["article", "div#article", "main", "div.container"];
-    for (const selector of selectors) {
-        const element = select(selector, hast);
-        if (element)
-            return element;
-    }
-    return hast;
+  }
+  const selectors = ["article", "div#article", "main", "div.container"];
+  for (const selector of selectors) {
+    const element = select(selector, hast);
+    if (element)
+      return element;
+  }
+  return hast;
+};
+export {
+  extractHast
 };
-//# sourceMappingURL=extract-hast.js.map

package/dist/html-to-markdown.js

@@ -1,8 +1,11 @@
-import { htmlToMdast } from "./html-to-mdast";
-import { mdastToMarkdown } from "./mdast-to-markdown";
-export const htmlToMarkdown = (html, options) => {
-    const mdast = htmlToMdast(html, options);
-    const markdown = mdastToMarkdown(mdast, options);
-    return markdown;
+// src/html-to-markdown.ts
+import { htmlToMdast } from "./html-to-mdast.js";
+import { mdastToMarkdown } from "./mdast-to-markdown.js";
+var htmlToMarkdown = (html, options) => {
+  const mdast = htmlToMdast(html, options);
+  const markdown = mdastToMarkdown(mdast, options);
+  return markdown;
+};
+export {
+  htmlToMarkdown
 };
-//# sourceMappingURL=html-to-markdown.js.map

package/dist/html-to-mdast.js

@@ -1,14 +1,18 @@
+// src/html-to-mdast.ts
 import { fromHtml } from "hast-util-from-html";
 import { toMdast } from "hast-util-to-mdast";
-import { extractHast } from "./extract-hast";
-import { customDivHandler } from "./mdast-handlers/custom-div-handler";
-import { mathHandler } from "./mdast-handlers/math-handler";
-export const htmlToMdast = (html, options) => {
-    const hast = fromHtml(html, { fragment: true });
-    const extractedHast = options?.extractHast ? options.extractHast(hast) : extractHast(hast);
-    const mdast = toMdast(extractedHast, {
-        handlers: { div: customDivHandler, math: mathHandler, br: () => { } },
-    });
-    return mdast;
+import { extractHast } from "./extract-hast.js";
+import { customDivHandler } from "./mdast-handlers/custom-div-handler.js";
+import { mathHandler } from "./mdast-handlers/math-handler.js";
+var htmlToMdast = (html, options) => {
+  const hast = fromHtml(html, { fragment: true });
+  const extractedHast = options?.extractHast ? options.extractHast(hast) : extractHast(hast);
+  const mdast = toMdast(extractedHast, {
+    handlers: { div: customDivHandler, math: mathHandler, br: () => {
+    } }
+  });
+  return mdast;
+};
+export {
+  htmlToMdast
 };
-//# sourceMappingURL=html-to-mdast.js.map

package/dist/index.js

@@ -1,5 +1,5 @@
-export * from "./html-to-markdown";
-export * from "./md-splitter";
-export * from "./html-to-mdast";
-export * from "./mdast-to-markdown";
-//# sourceMappingURL=index.js.map
+// src/index.ts
+export * from "./html-to-markdown.js";
+export * from "./md-splitter.js";
+export * from "./html-to-mdast.js";
+export * from "./mdast-to-markdown.js";

package/dist/link-replacer.js

@@ -1,9 +1,12 @@
-export const linkReplacer = (markdown, link) => {
-    const regex = /(!?\[.*?\]\()(.+?)(\))/g;
-    return markdown.replace(regex, (match, pre, thisUrl, post) => {
-        if (thisUrl.startsWith("http") || thisUrl.startsWith("#"))
-            return match;
-        return `${pre}${new URL(thisUrl, link).href}${post}`;
-    });
+// src/link-replacer.ts
+var linkReplacer = (markdown, link) => {
+  const regex = /(!?\[.*?\]\()(.+?)(\))/g;
+  return markdown.replace(regex, (match, pre, thisUrl, post) => {
+    if (thisUrl.startsWith("http") || thisUrl.startsWith("#"))
+      return match;
+    return `${pre}${new URL(thisUrl, link).href}${post}`;
+  });
+};
+export {
+  linkReplacer
 };
-//# sourceMappingURL=link-replacer.js.map