webforai 1.2.2 → 1.2.3

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

@@ -0,0 +1,43 @@
+"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_code_handler_exports = {};
+__export(custom_code_handler_exports, {
+  customCodeHandler: () => customCodeHandler
+});
+module.exports = __toCommonJS(custom_code_handler_exports);
+var import_hast_util_to_text = require("hast-util-to-text");
+var import_trim_trailing_lines = require("trim-trailing-lines");
+var import_detect_code_lang = require("../utils/detect-code-lang");
+const LANGUAGE_MATCH_REGEX = [/language-(\w+)/, /highlight-source-(\w+)/, /CodeBlock--language-(\w+)/];
+const customCodeHandler = (state, node) => {
+  const classNames = node.properties?.className || [];
+  const codeValue = (0, import_trim_trailing_lines.trimTrailingLines)((0, import_hast_util_to_text.toText)(node)).trim();
+  const classLang = classNames.map((className) => {
+    const match = LANGUAGE_MATCH_REGEX.map((regex) => className.match(regex)).find((match2) => match2);
+    return match?.[1];
+  }).find((className) => className);
+  const lang = classLang || (0, import_detect_code_lang.detectLanguage)(codeValue) || null;
+  const result = { type: "code", lang, meta: null, value: codeValue };
+  state.patch(node, result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customCodeHandler
+});

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

@@ -29,35 +29,41 @@ var import_trim_trailing_lines = require("trim-trailing-lines");
 var import_detect_code_lang = require("../utils/detect-code-lang");
 const CODE_BLOCK_REGEX = /highlight-source|language-|codegroup|codeblock|code-block/i;
 const CODE_FILENAME_SELECTORS = "[class*='fileName'],[class*='fileName'],[class*='title'],[class*='Title']";
-const LANGUAGE_MATCH_REGEX = /language-(\w+)|highlight-source-(\w+)/;
+const LANGUAGE_MATCH_REGEX = [/language-(\w+)/, /highlight-source-(\w+)/, /CodeBlock--language-(\w+)/];
 const findRecursive = (array, condition, maxDepth = 3) => {
-  if (maxDepth <= 0)
+  if (maxDepth <= 0) {
     return null;
+  }
   for (const value of array) {
     const result = condition(value);
-    if (Array.isArray(result))
+    if (Array.isArray(result)) {
       return findRecursive(result, condition, maxDepth - 1);
-    if (result)
+    }
+    if (result) {
       return value;
+    }
   }
   return null;
 };
 const customDivHandler = (state, node) => {
   const classNames = Array.isArray(node.properties.className) ? node.properties.className : [];
   const codeBlock = findRecursive(node.children, (child) => {
-    if (child.type !== "element")
+    if (child.type !== "element") {
       return false;
-    if (child.tagName === "pre")
+    }
+    if (child.tagName === "pre") {
       return true;
+    }
     return child.children.filter((child2) => child2.type === "element");
   });
   if (codeBlock && classNames.some((className) => CODE_BLOCK_REGEX.test(className))) {
+    const codeBlockClassNames = codeBlock.type === "element" ? codeBlock.properties.className ?? [] : [];
     const codeValue = (0, import_trim_trailing_lines.trimTrailingLines)((0, import_hast_util_to_text.toText)(codeBlock)).trim();
     const filenameElement = (0, import_hast_util_select.select)(CODE_FILENAME_SELECTORS, node);
     const fileLang = filenameElement ? (0, import_hast_util_to_string.toString)(filenameElement).match(/\.(\w+)$/)?.[1] : null;
-    const classLang = classNames.map((className) => {
-      const match = className.match(LANGUAGE_MATCH_REGEX);
-      return match?.[1] || match?.[2];
+    const classLang = [...classNames, ...codeBlockClassNames].map((className) => {
+      const match = LANGUAGE_MATCH_REGEX.map((regex) => className.match(regex)).find((match2) => match2);
+      return match?.[1];
     }).find((className) => className);
     const lang = fileLang || classLang || (0, import_detect_code_lang.detectLanguage)(codeValue) || null;
     const result = { type: "code", lang, meta: null, value: codeValue };

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

@@ -23,8 +23,9 @@ __export(custom_img_handler_exports, {
 module.exports = __toCommonJS(custom_img_handler_exports);
 var import_hast_util_to_mdast = require("hast-util-to-mdast");
 const customImgHandler = (options) => (state, node) => {
-  if (options?.hideImage)
+  if (options?.hideImage) {
     return void 0;
+  }
   return import_hast_util_to_mdast.defaultHandlers.image(state, node);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -0,0 +1,29 @@
+"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 empty_handler_exports = {};
+__export(empty_handler_exports, {
+  emptyHandler: () => emptyHandler
+});
+module.exports = __toCommonJS(empty_handler_exports);
+const emptyHandler = () => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emptyHandler
+});

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

@@ -30,8 +30,9 @@ 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?.url)
+  if (options?.url) {
     markdown = (0, import_link_replacer.linkReplacer)(markdown, options.url);
+  }
   return markdown;
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -24,18 +24,21 @@ __export(mdast_utils_exports, {
 });
 module.exports = __toCommonJS(mdast_utils_exports);
 const unwarpRoot = (mdast) => {
-  if (mdast.type === "root")
+  if (mdast.type === "root") {
     return mdast.children;
+  }
   return [mdast];
 };
 const warpRoot = (mdast) => {
-  if (Array.isArray(mdast))
+  if (Array.isArray(mdast)) {
     return { type: "root", children: mdast };
+  }
   return mdast;
 };
 const internalType = (content) => {
-  if (content.type === "heading")
+  if (content.type === "heading") {
     return `h${content.depth}`;
+  }
   return content.type;
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/extract-hast/index.js

@@ -1,2 +1,29 @@
 // src/extract-hast/index.ts
-export * from "./strongly.js";
+import { readabilityExtractHast } from "./readability.js";
+import { stronglyExtractHast } from "./strongly.js";
+var PRESET_EXTRACT_HAST = {
+  strongly: stronglyExtractHast,
+  readability: readabilityExtractHast
+};
+var DEFAULT_EXTRACT_HAST = ["readability"];
+var extractHast = (hast, extractors = DEFAULT_EXTRACT_HAST) => {
+  const _extractors = Array.isArray(extractors) ? extractors : [extractors];
+  const extracted = _extractors.reduce((acc, extractor) => {
+    if (extractor === false) {
+      return acc;
+    }
+    if (typeof extractor === "string" && extractor in DEFAULT_EXTRACT_HAST) {
+      return PRESET_EXTRACT_HAST[extractor](acc);
+    }
+    if (typeof extractor === "function") {
+      return extractor(acc);
+    }
+    throw new Error(`Invalid extractor: ${extractor}`);
+  }, hast) || hast;
+  return extracted;
+};
+export {
+  DEFAULT_EXTRACT_HAST,
+  PRESET_EXTRACT_HAST,
+  extractHast
+};

package/dist/extract-hast/readability.js

@@ -1,6 +1,6 @@
 // src/extract-hast/readability.ts
 import { select, selectAll } from "hast-util-select";
-import { toString } from "hast-util-to-string";
+import { toString as hastToString } from "hast-util-to-string";
 import { filter } from "unist-util-filter";
 import { parents } from "unist-util-parents";
 import { classnames, hasAncestors, isStrInclude, matchString } from "./utils.js";
@@ -9,7 +9,7 @@ var REGEXPS = {
   hidden: /hidden|invisible|fallback-image/i,
   byline: /byline|author|dateline|writtenby|p-author/i,
   unlikelyCandidates: /-ad-|ai2html|banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|footer|gdpr|header|legends|menu|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote|speechify-ignore/i,
-  okMaybeItsACandidate: /and|article|body|column|content|main|shadow|code/i
+  okMaybeItsaCandidate: /and|article|body|column|content|main|shadow|code/i
 };
 var BODY_SELECTORS = ["article", "#article", ".article_body", ".article-body", "#content", ".entry", "main"];
 var PARAGRAPH_TAGS = ["p", "div", "section", "article", "main", "ul", "ol", "li"];
@@ -18,60 +18,79 @@ var BASE_MINIMAL_LENGTH = {
   en: 500
 };
 var tryGetLang = (node) => {
-  if (node.type !== "element")
+  if (node.type !== "element") {
     return;
+  }
   const element = node;
-  if (element.tagName !== "html")
+  if (element.tagName !== "html") {
     return;
+  }
   const langAttr = element.properties.lang || element.properties["xml:lang"];
-  if (langAttr)
+  if (langAttr) {
     return langAttr;
+  }
 };
 var metadataFilter = (node) => !["comment", "doctype"].includes(node.type);
 var universalElementFilter = (node) => {
-  if (node.type !== "element")
+  if (node.type !== "element") {
     return true;
+  }
   const element = node;
-  if (["script", "aside"].includes(element.tagName))
+  if (["script", "aside"].includes(element.tagName)) {
     return false;
-  if (["hidden", "aria-hidden"].some((key) => element.properties[key]))
+  }
+  if (["hidden", "aria-hidden"].some((key) => element.properties[key])) {
     return false;
-  if (classnames(element).some((classname) => REGEXPS.hidden.test(classname)))
+  }
+  if (classnames(element).some((classname) => REGEXPS.hidden.test(classname))) {
     return false;
-  if (element.tagName === "dialog")
+  }
+  if (element.tagName === "dialog") {
     return false;
-  if (element.properties.role === "dialog" && element.properties["aria-modal"])
+  }
+  if (element.properties.role === "dialog" && element.properties["aria-modal"]) {
     return false;
-  if (element.properties.rel === "author" && isStrInclude(element.properties.itemprop, "author"))
+  }
+  if (element.properties.rel === "author" && isStrInclude(element.properties.itemprop, "author")) {
     return false;
-  if (REGEXPS.byline.test(matchString(element)))
+  }
+  if (REGEXPS.byline.test(matchString(element))) {
     return false;
-  if (element.properties.role && UNLIKELY_ROLES.includes(element.properties.role))
+  }
+  if (element.properties.role && UNLIKELY_ROLES.includes(element.properties.role)) {
     return false;
+  }
   return true;
 };
 var unlikelyElementFilter = (node) => {
-  if (node.type !== "element")
+  if (node.type !== "element") {
     return true;
+  }
   const element = node;
   const match = matchString(element);
-  if (["body", "article", "main", "section", "a"].includes(element.tagName))
+  if (["body", "article", "main", "section", "a"].includes(element.tagName)) {
     return true;
-  if (hasAncestors(element, ["table", "code"], 3))
+  }
+  if (hasAncestors(element, ["table", "code"], 3)) {
     return true;
-  if (REGEXPS.unlikelyCandidates.test(match) && !REGEXPS.okMaybeItsACandidate.test(match))
+  }
+  if (REGEXPS.unlikelyCandidates.test(match) && !REGEXPS.okMaybeItsaCandidate.test(match)) {
     return false;
+  }
   return true;
 };
 var removeEmptyFilter = (node) => {
-  if (node.type !== "element")
+  if (node.type !== "element") {
     return true;
+  }
   const element = node;
-  if (!PARAGRAPH_TAGS.includes(element.tagName))
+  if (!PARAGRAPH_TAGS.includes(element.tagName)) {
     return true;
-  const text = toString(element);
-  if (text.length < 10)
+  }
+  const text = hastToString(element);
+  if (text.length < 10) {
     return false;
+  }
   return true;
 };
 var readabilityExtractHast = (hast) => {
@@ -79,45 +98,54 @@ var readabilityExtractHast = (hast) => {
   const body = select("body", hast) ?? hast;
   const proxiedHast = parents(body);
   let baseFilterd = filter(proxiedHast, (node) => {
-    if (!metadataFilter(node))
+    if (!metadataFilter(node)) {
       return false;
-    if (!universalElementFilter(node))
+    }
+    if (!universalElementFilter(node)) {
       return false;
+    }
     return true;
   });
-  if (!baseFilterd)
+  if (!baseFilterd) {
     return { type: "root", children: [] };
-  const baseText = toString(baseFilterd);
+  }
+  const baseText = hastToString(baseFilterd);
   let minimalLength = lang in BASE_MINIMAL_LENGTH ? BASE_MINIMAL_LENGTH[lang] : 500;
   if (baseText.length > minimalLength) {
     const filterd = filter(baseFilterd, (node) => {
-      if (!unlikelyElementFilter(node))
+      if (!unlikelyElementFilter(node)) {
         return false;
+      }
       return true;
     });
-    if (filterd)
+    if (filterd) {
       baseFilterd = filterd;
-  } else
+    }
+  } else {
     minimalLength = Math.max(0, baseText.length - 200);
+  }
   let bodyTree = baseFilterd;
   for (const selector of BODY_SELECTORS) {
     const body2 = { type: "root", children: selectAll(selector, baseFilterd) };
-    const bodyText = toString(body2);
-    if (bodyText.length < 25)
+    const bodyText = hastToString(body2);
+    if (bodyText.length < 25) {
       continue;
+    }
     const links = selectAll("a", body2);
-    const linkText = links.map((link) => toString(link)).join("");
+    const linkText = links.map((link) => hastToString(link)).join("");
     const linkDensity = linkText.length / bodyText.length;
-    if (linkDensity > 0.4)
+    if (linkDensity > 0.4) {
       continue;
+    }
     if (bodyText.length > minimalLength) {
       bodyTree = body2;
       break;
     }
   }
   const finalTree = filter(bodyTree, (node) => {
-    if (!removeEmptyFilter(node))
+    if (!removeEmptyFilter(node)) {
       return false;
+    }
     return true;
   });
   return finalTree;

package/dist/extract-hast/strongly.js

@@ -13,14 +13,17 @@ var stronglyExtractHast = (hast) => {
     }
   }
   const removedElements = filter(selectedElement, (node) => {
-    if (node.type === "comment")
+    if (node.type === "comment") {
       return false;
-    if (node.type !== "element")
+    }
+    if (node.type !== "element") {
       return true;
+    }
     const element = node;
     const elementName = `${element.tagName} ${element.properties.id} ${element.properties.className}`;
-    if (REMOVE_REGEX.test(elementName))
+    if (REMOVE_REGEX.test(elementName)) {
       return false;
+    }
     return true;
   });
   return removedElements;

package/dist/extract-hast/utils.js

@@ -1,22 +1,26 @@
 // src/extract-hast/utils.ts
 var matchString = (element) => `${element.tagName} ${element.properties.id} ${classnames(element).join(" ")} }`;
 var classnames = (element) => {
-  if (Array.isArray(element.properties.className))
+  if (Array.isArray(element.properties.className)) {
     return element.properties.className;
+  }
   return [];
 };
 var isStrInclude = (value, match) => {
-  if (typeof value === "string")
+  if (typeof value === "string") {
     return value.includes(match);
+  }
   return false;
 };
 var hasAncestors = (element, tagNames, depth = 3) => {
   let parent = element.parent;
   for (let i = 0; i < depth; i++) {
-    if (!parent || parent.type !== "element")
+    if (!parent || parent.type !== "element") {
       return false;
-    if (tagNames.includes(parent.tagName))
+    }
+    if (tagNames.includes(parent.tagName)) {
       return true;
+    }
     parent = parent.parent;
   }
   return false;

package/dist/html-to-mdast.js

@@ -1,40 +1,27 @@
 // src/html-to-mdast.ts
 import { fromHtml } from "hast-util-from-html";
 import { toMdast } from "hast-util-to-mdast";
-import { stronglyExtractHast } from "./extract-hast/index.js";
-import { readabilityExtractHast } from "./extract-hast/readability.js";
+import { extractHast } from "./extract-hast/index.js";
 import { customAHandler } from "./mdast-handlers/custom-a-handler.js";
+import { customCodeHandler } from "./mdast-handlers/custom-code-handler.js";
 import { customDivHandler } from "./mdast-handlers/custom-div-handler.js";
 import { customImgHandler } from "./mdast-handlers/custom-img-handler.js";
 import { customTableHandler } from "./mdast-handlers/custom-table-handler.js";
+import { emptyHandler } from "./mdast-handlers/empty-handler.js";
 import { mathHandler } from "./mdast-handlers/math-handler.js";
-var PRESET_EXTRACT_HAST = {
-  strongly: stronglyExtractHast,
-  readability: readabilityExtractHast
-};
-var DEFAULT_EXTRACT_HAST = ["readability"];
 var htmlToMdast = (html, options) => {
-  const { extractHast = DEFAULT_EXTRACT_HAST } = options || {};
-  const _extractHast = Array.isArray(extractHast) ? extractHast : [extractHast];
+  const { extractHast: _extractHast } = options || {};
   const hast = fromHtml(html, { fragment: true });
-  const extractedHast = _extractHast.reduce((acc, extractHast2) => {
-    if (extractHast2 === false)
-      return acc;
-    if (typeof extractHast2 === "string" && extractHast2 in PRESET_EXTRACT_HAST)
-      return PRESET_EXTRACT_HAST[extractHast2](acc);
-    if (typeof extractHast2 === "function")
-      return extractHast2(acc);
-    throw new Error(`Invalid extractHast: ${extractHast2}`);
-  }, hast) || hast;
+  const extractedHast = extractHast(hast, _extractHast);
   const mdast = toMdast(extractedHast, {
     handlers: {
       math: mathHandler,
       div: customDivHandler,
+      pre: customCodeHandler,
       a: customAHandler({ asText: options?.linkAsText }),
       img: customImgHandler({ hideImage: options?.hideImage }),
       table: customTableHandler({ asText: options?.tableAsText }),
-      br: () => {
-      }
+      br: emptyHandler
     }
   });
   return mdast;

package/dist/index.js

@@ -1,5 +1,11 @@
 // 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";
+import { htmlToMarkdown } from "./html-to-markdown.js";
+import { mdastSplitter } from "./md-splitter.js";
+import { htmlToMdast } from "./html-to-mdast.js";
+import { mdastToMarkdown } from "./mdast-to-markdown.js";
+export {
+  htmlToMarkdown,
+  htmlToMdast,
+  mdastSplitter,
+  mdastToMarkdown
+};

package/dist/link-replacer.js

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

package/dist/loaders/playwright.js

@@ -1,21 +1,23 @@
 // src/loaders/playwright.ts
-import * as playwright from "playwright";
+import { chromium } from "playwright";
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var loadHtml = async (url, context) => {
   let _browser = null;
   let _context;
-  if (!context) {
-    _browser = await playwright.chromium.launch({ headless: true });
-    _context = await _browser.newContext();
-  } else
+  if (context) {
     _context = context;
+  } else {
+    _browser = await chromium.launch({ headless: true });
+    _context = await _browser.newContext();
+  }
   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)
+  if (_browser) {
     await _browser.close();
+  }
   return html;
 };
 export {

package/dist/md-splitter.js

@@ -4,14 +4,16 @@ import { chunk } from "./utils/common.js";
 import { internalType, unwarpRoot, warpRoot } from "./utils/mdast-utils.js";
 var PRIORITY_SPLITTERS = ["h1", "h2", "h3", "h4", "h5", "h6", "list", "table", "code"];
 var getSplitterGenerator = function* () {
-  for (const splitter of PRIORITY_SPLITTERS)
+  for (const splitter of PRIORITY_SPLITTERS) {
     yield splitter;
+  }
 };
 var _mdastSplitter = async (contents, checker, splitterGenerator) => {
   const splitter = splitterGenerator.next().value;
   const markdown = mdastToMarkdown(warpRoot(contents));
-  if (await checker(markdown) || contents.length === 1)
+  if (await checker(markdown) || contents.length === 1) {
     return [contents];
+  }
   const chunked = splitter ? contents.reduce((acc, content) => {
     if (internalType(content) === splitter || acc.length === 0) {
       acc.push([content]);
@@ -23,7 +25,7 @@ var _mdastSplitter = async (contents, checker, splitterGenerator) => {
   const splitting = chunked.map((chunk2) => _mdastSplitter(chunk2, checker, splitterGenerator));
   return Promise.all(splitting).then((chunks) => chunks.flat());
 };
-var mdastSplitter = async (mdast, checker, options) => {
+var mdastSplitter = (mdast, checker, _options) => {
   return _mdastSplitter(unwarpRoot(mdast), checker, getSplitterGenerator());
 };
 export {

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

@@ -1,15 +1,16 @@
 // src/mdast-handlers/custom-a-handler.ts
 import { defaultHandlers } from "hast-util-to-mdast";
-import { toString } from "hast-util-to-string";
+import { toString as hastToString } from "hast-util-to-string";
 var customAHandler = (options) => (state, node) => {
   if (options?.asText) {
-    const link2 = { type: "text", value: toString(node) };
+    const link2 = { type: "text", value: hastToString(node) };
     state.patch(node, link2);
     return link2;
   }
   const link = defaultHandlers.a(state, node);
-  if (link.children.length > 0)
+  if (link.children.length > 0) {
     return link;
+  }
   return void 0;
 };
 export {

package/dist/mdast-handlers/custom-code-handler.js

@@ -0,0 +1,20 @@
+// src/mdast-handlers/custom-code-handler.ts
+import { toText } from "hast-util-to-text";
+import { trimTrailingLines } from "trim-trailing-lines";
+import { detectLanguage } from "../utils/detect-code-lang.js";
+var LANGUAGE_MATCH_REGEX = [/language-(\w+)/, /highlight-source-(\w+)/, /CodeBlock--language-(\w+)/];
+var customCodeHandler = (state, node) => {
+  const classNames = node.properties?.className || [];
+  const codeValue = trimTrailingLines(toText(node)).trim();
+  const classLang = classNames.map((className) => {
+    const match = LANGUAGE_MATCH_REGEX.map((regex) => className.match(regex)).find((match2) => match2);
+    return match?.[1];
+  }).find((className) => className);
+  const lang = classLang || detectLanguage(codeValue) || null;
+  const result = { type: "code", lang, meta: null, value: codeValue };
+  state.patch(node, result);
+  return result;
+};
+export {
+  customCodeHandler
+};