@scalar/code-highlight 0.2.4 → 0.3.1

package/dist/markdown/markdown.js

@@ -1,114 +1,162 @@
-import rehypeExternalLinks from "rehype-external-links";
-import rehypeFormat from "rehype-format";
-import rehypeRaw from "rehype-raw";
-import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
-import rehypeStringify from "rehype-stringify";
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import remarkRehype from "remark-rehype";
-import remarkStringify from "remark-stringify";
-import { unified } from "unified";
-import { SKIP, visit } from "unist-util-visit";
-import { standardLanguages } from "../languages/index.js";
-import { rehypeAlert } from "../rehype-alert/index.js";
-import { rehypeHighlight } from "../rehype-highlight/index.js";
-const isHeading = (node) => {
-  return node.type === "heading" && "depth" in node && "children" in node;
+import rehypeExternalLinks from 'rehype-external-links';
+import rehypeFormat from 'rehype-format';
+import rehypeRaw from 'rehype-raw';
+import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import remarkRehype from 'remark-rehype';
+import remarkStringify from 'remark-stringify';
+import { unified } from 'unified';
+import { SKIP, visit } from 'unist-util-visit';
+import { standardLanguages } from '../languages/index.js';
+import { rehypeAlert } from '../rehype-alert/index.js';
+import { rehypeHighlight } from '../rehype-highlight/index.js';
+/**
+ * Type-guard to check if a node is a heading.
+ */
+export const isHeading = (node) => {
+    return node.type === 'heading' && 'depth' in node && 'children' in node;
 };
+/**
+ * Plugin to transform nodes in a Markdown AST
+ */
 const transformNodes = (options, ..._ignored) => (tree) => {
-  if (!options?.transform || !options?.type) {
+    if (!options?.transform || !options?.type) {
+        return;
+    }
+    visit(tree, options?.type, (node) => {
+        options?.transform ? options?.transform(node) : node;
+        return SKIP;
+    });
     return;
-  }
-  visit(tree, options?.type, (node) => {
-    options?.transform ? options?.transform(node) : node;
-    return SKIP;
-  });
-  return;
 };
-function htmlFromMarkdown(markdown, options) {
-  const removeTags = options?.removeTags ?? [];
-  const tagNames = [...defaultSchema.tagNames ?? [], ...options?.allowTags ?? []].filter(
-    (t) => !removeTags.includes(t)
-  );
-  const html = unified().use(remarkParse).use(remarkGfm).use(transformNodes, {
-    transform: options?.transform,
-    type: options?.transformType
-  }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeAlert).use(rehypeRaw).use(rehypeSanitize, {
-    ...defaultSchema,
-    // Don't prefix the heading ids
-    clobberPrefix: "",
-    // Makes it even more strict
-    tagNames,
-    attributes: {
-      ...defaultSchema.attributes,
-      abbr: ["title"],
-      // Allow all class names while preserving the existing default attributes
-      "*": [...defaultSchema.attributes?.["*"] ?? [], "className"]
-    },
-    // Strip content of dangerous elements, not just the tags
-    strip: ["script", "style", "object", "embed", "form"]
-  }).use(rehypeHighlight, {
-    languages: standardLanguages,
-    // Enable auto detection
-    detect: true
-  }).use(rehypeExternalLinks, { target: "_blank" }).use(rehypeFormat).use(rehypeStringify).processSync(markdown);
-  return html.toString();
+/**
+ * Take a Markdown string and generate HTML from it
+ */
+export function htmlFromMarkdown(markdown, options) {
+    // Add permitted tags and remove stripped ones
+    const removeTags = options?.removeTags ?? [];
+    const tagNames = [...(defaultSchema.tagNames ?? []), ...(options?.allowTags ?? [])].filter((t) => !removeTags.includes(t));
+    const html = unified()
+        // Parses markdown
+        .use(remarkParse)
+        // Support autolink literals, footnotes, strikethrough, tables and tasklists
+        .use(remarkGfm)
+        .use(transformNodes, {
+        transform: options?.transform,
+        type: options?.transformType,
+    })
+        // Allows any HTML tags
+        .use(remarkRehype, { allowDangerousHtml: true })
+        // Adds GitHub alerts
+        .use(rehypeAlert)
+        // Creates a HTML AST
+        .use(rehypeRaw)
+        // Removes disallowed tags
+        .use(rehypeSanitize, {
+        ...defaultSchema,
+        // Don't prefix the heading ids
+        clobberPrefix: '',
+        // Makes it even more strict
+        tagNames,
+        attributes: {
+            ...defaultSchema.attributes,
+            abbr: ['title'],
+            // Allow all class names while preserving the existing default attributes
+            '*': [...(defaultSchema.attributes?.['*'] ?? []), 'className'],
+        },
+        // Strip content of dangerous elements, not just the tags
+        strip: ['script', 'style', 'object', 'embed', 'form'],
+    })
+        // Syntax highlighting
+        .use(rehypeHighlight, {
+        languages: standardLanguages,
+        // Enable auto detection
+        detect: true,
+    })
+        // Adds target="_blank" to external links
+        .use(rehypeExternalLinks, { target: '_blank' })
+        // Formats the HTML
+        .use(rehypeFormat)
+        // Converts the HTML AST to a string
+        .use(rehypeStringify)
+        // Run the pipeline
+        .processSync(markdown);
+    return html.toString();
 }
+/**
+ * Create a Markdown AST from a string.
+ */
 function getMarkdownAst(markdown) {
-  return unified().use(remarkParse).use(remarkGfm).parse(markdown);
+    return unified().use(remarkParse).use(remarkGfm).parse(markdown);
 }
-function getHeadings(markdown, depth = 1) {
-  const tree = getMarkdownAst(markdown);
-  const nodes = [];
-  visit(tree, "heading", (node) => {
-    const text = textFromNode(node);
-    if (text) {
-      nodes.push({ depth: node.depth ?? depth, value: text });
-    }
-  });
-  return nodes;
+/**
+ * Find all headings of a specific type in a Markdown AST.
+ */
+export function getHeadings(markdown, depth = 1) {
+    const tree = getMarkdownAst(markdown);
+    const nodes = [];
+    visit(tree, 'heading', (node) => {
+        const text = textFromNode(node);
+        if (text) {
+            nodes.push({ depth: node.depth ?? depth, value: text });
+        }
+    });
+    return nodes;
 }
-function textFromNode(node) {
-  if (node.type === "text") {
-    return node.value ?? "";
-  }
-  if ("children" in node && Array.isArray(node.children)) {
-    return node.children.map((child) => textFromNode(child)).join("");
-  }
-  return "";
+/**
+ * Extract plain text from a Markdown AST node (recursively).
+ *
+ * Handles headings with nested phrasing content such as links.
+ */
+export function textFromNode(node) {
+    if (node.type === 'text') {
+        return node.value ?? '';
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+        return node.children.map((child) => textFromNode(child)).join('');
+    }
+    return '';
 }
-function splitContent(markdown) {
-  const tree = getMarkdownAst(markdown);
-  const sections = [];
-  let nodes = [];
-  tree.children?.forEach((node) => {
-    if (node.type === "heading") {
-      if (nodes.length) {
+/**
+ * Return multiple Markdown documents. Every heading should be its own document.
+ */
+export function splitContent(markdown) {
+    const tree = getMarkdownAst(markdown);
+    /** Sections */
+    const sections = [];
+    /** Nodes inside a section */
+    let nodes = [];
+    tree.children?.forEach((node) => {
+        // If the node is a heading, start a new section
+        if (node.type === 'heading') {
+            if (nodes.length) {
+                sections.push(nodes);
+            }
+            sections.push([node]);
+            nodes = [];
+        }
+        // Otherwise, add the node to the current section
+        else {
+            nodes.push(node);
+        }
+    });
+    // Add any remaining nodes
+    if (nodes.length) {
         sections.push(nodes);
-      }
-      sections.push([node]);
-      nodes = [];
-    } else {
-      nodes.push(node);
     }
-  });
-  if (nodes.length) {
-    sections.push(nodes);
-  }
-  return sections.map((section) => createDocument(section));
+    return sections.map((section) => createDocument(section));
 }
+/**
+ * Use remark to create a Markdown document from a list of nodes.
+ */
 function createDocument(nodes) {
-  const markdown = unified().use(remarkStringify).use(remarkGfm).stringify({
-    type: "root",
-    children: nodes
-  });
-  return markdown.trim();
+    // Create the Markdown string
+    const markdown = unified().use(remarkStringify).use(remarkGfm).stringify({
+        type: 'root',
+        children: nodes,
+    });
+    // Remove the whitespace
+    return markdown.trim();
 }
-export {
-  getHeadings,
-  htmlFromMarkdown,
-  isHeading,
-  splitContent,
-  textFromNode
-};
-//# sourceMappingURL=markdown.js.map

package/dist/rehype-alert/index.js

@@ -1,5 +1 @@
-import { rehypeAlert } from "./rehype-alert.js";
-export {
-  rehypeAlert
-};
-//# sourceMappingURL=index.js.map
+export { rehypeAlert } from './rehype-alert.js';

package/dist/rehype-alert/rehype-alert.js

@@ -1,94 +1,102 @@
-import { visit } from "unist-util-visit";
-const ALERT_TYPES = ["note", "tip", "important", "warning", "caution", "success"];
+import { visit } from 'unist-util-visit';
+const ALERT_TYPES = ['note', 'tip', 'important', 'warning', 'caution', 'success'];
+// Simple whitespace check function
 function isWhitespace(node) {
-  return node.type === "text" && typeof node.value === "string" && /^\s*$/.test(node.value);
+    return node.type === 'text' && typeof node.value === 'string' && /^\s*$/.test(node.value);
 }
-function rehypeAlert() {
-  return (tree) => {
-    visit(tree, "element", (node, index, parent) => {
-      if (node.tagName !== "blockquote" || typeof index !== "number" || !parent || parent.type !== "root") {
-        return;
-      }
-      const headIndex = node.children.findIndex((child) => !isWhitespace(child));
-      if (headIndex === -1) {
-        return;
-      }
-      const head = node.children[headIndex];
-      if (!head || head.type !== "element" || head.tagName !== "p") {
-        return;
-      }
-      const text = head.children[0];
-      if (!text || text.type !== "text" || !text.value.startsWith("[!")) {
-        return;
-      }
-      const end = text.value.indexOf("]");
-      if (end === -1) {
-        return;
-      }
-      const alertType = text.value.slice(2, end).toLowerCase();
-      if (!ALERT_TYPES.includes(alertType)) {
-        return;
-      }
-      if (end + 1 === text.value.length) {
-        const next = head.children[1];
-        if (next) {
-          if (next.type !== "element" || next.tagName !== "br") {
-            return;
-          }
-          if (!head.children[2]) {
-            return;
-          }
-          head.children = head.children.slice(2);
-          const node2 = head.children[0];
-          if (node2 && node2.type === "text" && node2.value.charAt(0) === "\n") {
-            node2.value = node2.value.slice(1);
-          }
-        } else {
-          const skipped = headIndex + 1 < node.children.length && isWhitespace(node.children[headIndex + 1]);
-          const nextIndex = skipped ? headIndex + 2 : headIndex + 1;
-          if (nextIndex >= node.children.length || node.children[nextIndex]?.type !== "element") {
-            return;
-          }
-          node.children = node.children.slice(nextIndex);
-        }
-      } else if (text.value.charAt(end + 1) === "\n" && // Check if the next character is a newline or a non-whitespace character
-      (end + 2 === text.value.length || !/^\s*$/.test(text.value.slice(end + 2)))) {
-        text.value = text.value.slice(end + 2);
-      } else {
-        text.value = text.value.replace(/^\s*\[!.*?\]\s*/, "");
-      }
-      const contentChildren = [];
-      for (let i = headIndex; i < node.children.length; i++) {
-        const child = node.children[i];
-        if (child?.type === "element" && child.tagName === "p" && child.children) {
-          contentChildren.push(...child.children);
-        } else {
-          contentChildren.push(child);
-        }
-      }
-      parent.children[index] = {
-        type: "element",
-        tagName: "div",
-        properties: { className: ["markdown-alert", `markdown-alert-${alertType}`] },
-        children: [
-          {
-            type: "element",
-            tagName: "div",
-            properties: { className: ["markdown-alert-icon"] },
-            children: []
-          },
-          {
-            type: "element",
-            tagName: "div",
-            properties: { className: ["markdown-alert-content"] },
-            children: [{ type: "text", value: " " }, ...contentChildren]
-          }
-        ]
-      };
-    });
-  };
+export function rehypeAlert() {
+    return (tree) => {
+        visit(tree, 'element', (node, index, parent) => {
+            if (node.tagName !== 'blockquote' || typeof index !== 'number' || !parent || parent.type !== 'root') {
+                return;
+            }
+            // Find the first non-whitespace child
+            const headIndex = node.children.findIndex((child) => !isWhitespace(child));
+            if (headIndex === -1) {
+                return;
+            }
+            const head = node.children[headIndex];
+            if (!head || head.type !== 'element' || head.tagName !== 'p') {
+                return;
+            }
+            const text = head.children[0];
+            if (!text || text.type !== 'text' || !text.value.startsWith('[!')) {
+                return;
+            }
+            const end = text.value.indexOf(']');
+            if (end === -1) {
+                return;
+            }
+            // Extract the alert type
+            const alertType = text.value.slice(2, end).toLowerCase();
+            if (!ALERT_TYPES.includes(alertType)) {
+                return;
+            }
+            // Remove the blockquote if it's empty
+            if (end + 1 === text.value.length) {
+                const next = head.children[1];
+                if (next) {
+                    if (next.type !== 'element' || next.tagName !== 'br') {
+                        return;
+                    }
+                    if (!head.children[2]) {
+                        return;
+                    }
+                    head.children = head.children.slice(2);
+                    const node = head.children[0];
+                    if (node && node.type === 'text' && node.value.charAt(0) === '\n') {
+                        node.value = node.value.slice(1);
+                    }
+                }
+                else {
+                    const skipped = headIndex + 1 < node.children.length && isWhitespace(node.children[headIndex + 1]);
+                    const nextIndex = skipped ? headIndex + 2 : headIndex + 1;
+                    if (nextIndex >= node.children.length || node.children[nextIndex]?.type !== 'element') {
+                        return;
+                    }
+                    node.children = node.children.slice(nextIndex);
+                }
+            }
+            else if (text.value.charAt(end + 1) === '\n' &&
+                // Check if the next character is a newline or a non-whitespace character
+                (end + 2 === text.value.length || !/^\s*$/.test(text.value.slice(end + 2)))) {
+                text.value = text.value.slice(end + 2);
+            }
+            else {
+                // Remove the alert marker if it's not followed by a newline or a non-whitespace character
+                text.value = text.value.replace(/^\s*\[!.*?\]\s*/, '');
+            }
+            // Extract content from paragraphs to avoid wrapping in <p> tags
+            const contentChildren = [];
+            for (let i = headIndex; i < node.children.length; i++) {
+                const child = node.children[i];
+                if (child?.type === 'element' && child.tagName === 'p' && child.children) {
+                    contentChildren.push(...child.children);
+                }
+                else {
+                    contentChildren.push(child);
+                }
+            }
+            // Replace the blockquote with a div containing the alert
+            parent.children[index] = {
+                type: 'element',
+                tagName: 'div',
+                properties: { className: ['markdown-alert', `markdown-alert-${alertType}`] },
+                children: [
+                    {
+                        type: 'element',
+                        tagName: 'div',
+                        properties: { className: ['markdown-alert-icon'] },
+                        children: [],
+                    },
+                    {
+                        type: 'element',
+                        tagName: 'div',
+                        properties: { className: ['markdown-alert-content'] },
+                        children: [{ type: 'text', value: ' ' }, ...contentChildren],
+                    },
+                ],
+            };
+        });
+    };
 }
-export {
-  rehypeAlert
-};
-//# sourceMappingURL=rehype-alert.js.map

package/dist/rehype-highlight/index.js

@@ -1,5 +1 @@
-import { rehypeHighlight } from "./rehype-highlight.js";
-export {
-  rehypeHighlight
-};
-//# sourceMappingURL=index.js.map
+export { rehypeHighlight } from './rehype-highlight.js';