@changerawr/markdown 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,4 +1,3 @@
-"use client";
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -39,19 +38,43 @@ __export(index_exports, {
   MarkdownParser: () => MarkdownParser,
   MarkdownRenderer: () => MarkdownRenderer,
   PerformanceTimer: () => PerformanceTimer,
+  astToJSONString: () => astToJSONString,
+  astToTokens: () => astToTokens,
+  basicSanitize: () => basicSanitize,
+  compareTokens: () => compareTokens,
+  createCumEngine: () => createCumEngine,
   createCustomEngine: () => createCustomEngine,
   createDebugEngine: () => createDebugEngine,
   createEngine: () => createEngine,
+  createEngineWithPreset: () => createEngineWithPreset,
   createHTMLEngine: () => createHTMLEngine,
   createMinimalEngine: () => createMinimalEngine,
   createTailwindEngine: () => createTailwindEngine,
+  debounce: () => debounce,
+  deepMerge: () => deepMerge,
   default: () => index_default,
+  defaultTailwindClasses: () => defaultTailwindClasses,
   escapeHtml: () => escapeHtml,
   extractDomain: () => extractDomain,
   generateId: () => generateId,
+  getASTStats: () => getASTStats,
+  getTokenStats: () => getTokenStats,
+  isBrowser: () => isBrowser,
+  isNode: () => isNode,
+  isValidUrl: () => isValidUrl,
   markdown: () => markdown2,
+  minimalClasses: () => minimalClasses,
+  parseASTFromJSON: () => parseASTFromJSON,
+  parseCum: () => parseCum,
   parseMarkdown: () => parseMarkdown,
   parseOptions: () => parseOptions,
+  parseTokensFromJSON: () => parseTokensFromJSON,
+  presets: () => presets,
+  proseClasses: () => proseClasses,
+  renderCum: () => renderCum,
+  renderCumToHtml: () => renderCumToHtml,
+  renderCumToJson: () => renderCumToJson,
+  renderCumToTailwind: () => renderCumToTailwind,
   renderMarkdown: () => renderMarkdown,
   renderToAST: () => renderToAST,
   renderToHTML: () => renderToHTML,
@@ -61,7 +84,9 @@ __export(index_exports, {
   renderToTailwind: () => renderToTailwind,
   renderToTailwindWithClasses: () => renderToTailwindWithClasses,
   renderToTailwindWithConfig: () => renderToTailwindWithConfig,
-  sanitizeHtml: () => sanitizeHtml
+  sanitizeHtml: () => sanitizeHtml,
+  tokensToAST: () => tokensToAST,
+  tokensToJSONString: () => tokensToJSONString
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -610,6 +635,38 @@ function sanitizeHtml(html) {
 function basicSanitize(html) {
   return html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/on\w+\s*=\s*"[^"]*"/gi, "").replace(/on\w+\s*=\s*'[^']*'/gi, "").replace(/javascript:/gi, "");
 }
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      if (key in target && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        output[key] = deepMerge(target[key], source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
 function extractDomain(url) {
   try {
     return new URL(url).hostname;
@@ -617,6 +674,14 @@ function extractDomain(url) {
     return url;
   }
 }
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function parseOptions(options) {
   const parsed = {};
   if (!options) return parsed;
@@ -1585,37 +1650,6 @@ function renderToHTMLUnsafe(markdown3) {
   });
 }
 
-// src/outputs/tailwind.ts
-function renderToTailwind(markdown3, config) {
-  const engine = new ChangerawrMarkdown({
-    ...config,
-    renderer: {
-      format: "tailwind",
-      sanitize: true,
-      allowUnsafeHtml: false
-    }
-  });
-  return engine.toHtml(markdown3);
-}
-function renderToTailwindWithClasses(markdown3, customClasses) {
-  const engine = new ChangerawrMarkdown({
-    renderer: {
-      format: "tailwind",
-      ...customClasses && { customClasses }
-    }
-  });
-  return engine.toHtml(markdown3);
-}
-function renderToTailwindWithConfig(markdown3, rendererConfig) {
-  const engine = new ChangerawrMarkdown({
-    renderer: {
-      format: "tailwind",
-      ...rendererConfig
-    }
-  });
-  return engine.toHtml(markdown3);
-}
-
 // src/outputs/json.ts
 function renderToJSON(markdown3, config) {
   const engine = new ChangerawrMarkdown(config);
@@ -1697,9 +1731,305 @@ function tokensToAST(tokens) {
   }
   return ast;
 }
+function astToTokens(ast) {
+  const tokens = [];
+  function processNode(node) {
+    if (node.children && node.children.length > 0) {
+      if (node.type === "list" || node.type === "task-list" || node.type === "blockquote-group") {
+        node.children.forEach(processNode);
+        return;
+      }
+      if (node.type === "paragraph") {
+        node.children.forEach((child, index) => {
+          const token2 = {
+            type: child.type,
+            content: child.content,
+            raw: child.content,
+            ...child.attributes && { attributes: child.attributes }
+          };
+          tokens.push(token2);
+          if (index < node.children.length - 1 && isInlineToken(child)) {
+            tokens.push({
+              type: "soft-break",
+              content: " ",
+              raw: " "
+            });
+          }
+        });
+        tokens.push({
+          type: "paragraph-break",
+          content: "",
+          raw: "\n\n"
+        });
+        return;
+      }
+    }
+    const token = {
+      type: node.type,
+      content: node.content,
+      raw: node.content,
+      ...node.attributes && { attributes: node.attributes }
+    };
+    tokens.push(token);
+  }
+  ast.forEach(processNode);
+  return tokens;
+}
+function tokensToJSONString(tokens, pretty = true) {
+  if (pretty) {
+    return JSON.stringify(tokens, null, 2);
+  }
+  return JSON.stringify(tokens);
+}
+function astToJSONString(ast, pretty = true) {
+  if (pretty) {
+    return JSON.stringify(ast, null, 2);
+  }
+  return JSON.stringify(ast);
+}
+function parseTokensFromJSON(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (!Array.isArray(parsed)) {
+      throw new Error("JSON must be an array of tokens");
+    }
+    for (const token of parsed) {
+      if (!token.type || typeof token.type !== "string") {
+        throw new Error("Invalid token structure: missing or invalid type");
+      }
+      if (token.content === void 0 && token.raw === void 0) {
+        throw new Error("Invalid token structure: missing content and raw");
+      }
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse tokens from JSON: ${message}`);
+  }
+}
+function parseASTFromJSON(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (!Array.isArray(parsed)) {
+      throw new Error("JSON must be an array of AST nodes");
+    }
+    for (const node of parsed) {
+      if (!node.type || typeof node.type !== "string") {
+        throw new Error("Invalid AST node: missing or invalid type");
+      }
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse AST from JSON: ${message}`);
+  }
+}
+function getTokenStats(tokens) {
+  const tokenTypes = {};
+  const extensionTokens = {};
+  let totalContent = 0;
+  let totalRaw = 0;
+  let tokensWithAttributes = 0;
+  for (const token of tokens) {
+    tokenTypes[token.type] = (tokenTypes[token.type] || 0) + 1;
+    if (["alert", "button", "embed"].includes(token.type)) {
+      extensionTokens[token.type] = (extensionTokens[token.type] || 0) + 1;
+    }
+    totalContent += (token.content || "").length;
+    totalRaw += (token.raw || "").length;
+    if (token.attributes && Object.keys(token.attributes).length > 0) {
+      tokensWithAttributes++;
+    }
+  }
+  const totalTokens = tokens.length;
+  return {
+    totalTokens,
+    tokenTypes,
+    extensionTokens,
+    totalContent,
+    totalRaw,
+    tokensWithAttributes,
+    averageContentLength: totalTokens > 0 ? Math.round(totalContent / totalTokens) : 0,
+    averageRawLength: totalTokens > 0 ? Math.round(totalRaw / totalTokens) : 0,
+    attributeUsageRate: totalTokens > 0 ? Math.round(tokensWithAttributes / totalTokens * 100) : 0
+  };
+}
+function getASTStats(ast) {
+  let totalNodes = 0;
+  let maxDepth = 0;
+  let nodesWithChildren = 0;
+  let totalChildren = 0;
+  const nodeTypes = {};
+  function analyzeNode(node, depth = 0) {
+    totalNodes++;
+    maxDepth = Math.max(maxDepth, depth);
+    nodeTypes[node.type] = (nodeTypes[node.type] || 0) + 1;
+    if (node.children && node.children.length > 0) {
+      nodesWithChildren++;
+      totalChildren += node.children.length;
+      node.children.forEach((child) => analyzeNode(child, depth + 1));
+    }
+  }
+  ast.forEach((node) => analyzeNode(node));
+  return {
+    totalNodes,
+    maxDepth,
+    nodesWithChildren,
+    totalChildren,
+    nodeTypes,
+    averageChildrenPerParent: nodesWithChildren > 0 ? Math.round(totalChildren / nodesWithChildren) : 0,
+    hierarchyComplexity: maxDepth > 0 ? Math.round(totalChildren / totalNodes * maxDepth) : 0
+  };
+}
+function compareTokens(tokensA, tokensB) {
+  const differences = [];
+  const maxLength = Math.max(tokensA.length, tokensB.length);
+  for (let i = 0; i < maxLength; i++) {
+    const tokenA = tokensA[i];
+    const tokenB = tokensB[i];
+    if (!tokenA && tokenB) {
+      differences.push({
+        index: i,
+        type: "added",
+        tokenB
+      });
+    } else if (tokenA && !tokenB) {
+      differences.push({
+        index: i,
+        type: "removed",
+        tokenA
+      });
+    } else if (tokenA && tokenB) {
+      if (tokenA.type !== tokenB.type || tokenA.content !== tokenB.content) {
+        differences.push({
+          index: i,
+          type: "modified",
+          tokenA,
+          tokenB
+        });
+      }
+    }
+  }
+  return {
+    identical: differences.length === 0,
+    differences,
+    addedCount: differences.filter((d) => d.type === "added").length,
+    removedCount: differences.filter((d) => d.type === "removed").length,
+    modifiedCount: differences.filter((d) => d.type === "modified").length
+  };
+}
 function isParagraphContent(token) {
   return ["text", "bold", "italic", "code", "link", "soft-break"].includes(token.type);
 }
+function isInlineToken(node) {
+  return ["bold", "italic", "code", "link"].includes(node.type);
+}
+
+// src/outputs/tailwind.ts
+function renderToTailwind(markdown3, config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "tailwind",
+      sanitize: true,
+      allowUnsafeHtml: false
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToTailwindWithClasses(markdown3, customClasses) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "tailwind",
+      ...customClasses && { customClasses }
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToTailwindWithConfig(markdown3, rendererConfig) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "tailwind",
+      ...rendererConfig
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+var defaultTailwindClasses = {
+  // Typography
+  "heading-1": "text-3xl font-bold mt-8 mb-4",
+  "heading-2": "text-2xl font-semibold mt-6 mb-3",
+  "heading-3": "text-xl font-medium mt-5 mb-3",
+  "heading-4": "text-lg font-medium mt-4 mb-2",
+  "heading-5": "text-base font-medium mt-3 mb-2",
+  "heading-6": "text-sm font-medium mt-3 mb-2",
+  "paragraph": "leading-7 mb-4",
+  "blockquote": "pl-4 py-2 border-l-2 border-border italic text-muted-foreground my-4",
+  // Code
+  "code-inline": "bg-muted px-1.5 py-0.5 rounded text-sm font-mono",
+  "code-block": "bg-muted p-4 rounded-md overflow-x-auto my-4",
+  // Links and buttons
+  "link": "text-primary hover:underline inline-flex items-center gap-1",
+  "button": "inline-flex items-center justify-center font-medium rounded-lg transition-all duration-200",
+  // Lists
+  "list": "list-disc list-inside space-y-1",
+  "list-item": "ml-4",
+  // Images and media
+  "image": "max-w-full h-auto rounded-lg my-4",
+  "embed": "rounded-lg border bg-card text-card-foreground shadow-sm mb-6 overflow-hidden",
+  // Alerts
+  "alert": "border-l-4 p-4 mb-4 rounded-md transition-colors duration-200",
+  "alert-info": "bg-blue-500/10 border-blue-500/30 text-blue-600 border-l-blue-500",
+  "alert-warning": "bg-amber-500/10 border-amber-500/30 text-amber-600 border-l-amber-500",
+  "alert-error": "bg-red-500/10 border-red-500/30 text-red-600 border-l-red-500",
+  "alert-success": "bg-green-500/10 border-green-500/30 text-green-600 border-l-green-500"
+};
+var proseClasses = {
+  "heading-1": "text-4xl font-bold tracking-tight mt-10 mb-6",
+  "heading-2": "text-3xl font-semibold tracking-tight mt-8 mb-4",
+  "heading-3": "text-2xl font-medium tracking-tight mt-6 mb-3",
+  "paragraph": "text-lg leading-8 mb-6",
+  "blockquote": "border-l-4 border-gray-300 pl-6 py-2 italic text-gray-700 my-6",
+  "code-inline": "bg-gray-100 text-gray-800 px-2 py-1 rounded text-sm font-mono",
+  "code-block": "bg-gray-900 text-gray-100 p-6 rounded-lg overflow-x-auto my-6 text-sm",
+  "link": "text-blue-600 hover:text-blue-800 underline decoration-2 underline-offset-2"
+};
+var minimalClasses = {
+  "heading-1": "text-2xl font-semibold mb-4",
+  "heading-2": "text-xl font-medium mb-3",
+  "heading-3": "text-lg font-medium mb-2",
+  "paragraph": "mb-4",
+  "blockquote": "border-l-2 border-gray-300 pl-4 italic mb-4",
+  "code-inline": "bg-gray-100 px-1 rounded font-mono text-sm",
+  "code-block": "bg-gray-100 p-3 rounded font-mono text-sm mb-4",
+  "link": "text-blue-600 hover:underline"
+};
+
+// src/standalone.ts
+function renderCum(markdown3, config) {
+  const engine = new ChangerawrMarkdown(config);
+  return engine.toHtml(markdown3);
+}
+function parseCum(markdown3, config) {
+  const engine = new ChangerawrMarkdown(config);
+  return engine.parse(markdown3);
+}
+function createCumEngine(config) {
+  return new ChangerawrMarkdown(config);
+}
+function renderCumToHtml(markdown3) {
+  return renderCum(markdown3, {
+    renderer: { format: "html" }
+  });
+}
+function renderCumToTailwind(markdown3) {
+  return renderCum(markdown3, {
+    renderer: { format: "tailwind" }
+  });
+}
+function renderCumToJson(markdown3) {
+  return parseCum(markdown3);
+}
 
 // src/index.ts
 function createEngine(config) {
@@ -1711,7 +2041,8 @@ function createHTMLEngine(config) {
     renderer: {
       format: "html",
       sanitize: true,
-      allowUnsafeHtml: false
+      allowUnsafeHtml: false,
+      ...config?.parser
     }
   });
 }
@@ -1721,7 +2052,8 @@ function createTailwindEngine(config) {
     renderer: {
       format: "tailwind",
       sanitize: true,
-      allowUnsafeHtml: false
+      allowUnsafeHtml: false,
+      ...config?.parser
     }
   });
 }
@@ -1779,6 +2111,9 @@ var markdown2 = {
   createDebugEngine,
   createMinimalEngine,
   createCustomEngine,
+  // Standalone functions
+  renderCum,
+  parseCum,
   // Main class
   ChangerawrMarkdown,
   // Extensions
@@ -1799,6 +2134,71 @@ var markdown2 = {
   }
 };
 var index_default = markdown2;
+var presets = {
+  /**
+   * Blog/article preset with prose-friendly styling
+   */
+  blog: {
+    renderer: {
+      format: "tailwind",
+      customClasses: {
+        "heading-1": "text-4xl font-bold tracking-tight mt-10 mb-6",
+        "heading-2": "text-3xl font-semibold tracking-tight mt-8 mb-4",
+        "heading-3": "text-2xl font-medium tracking-tight mt-6 mb-3",
+        "paragraph": "text-lg leading-8 mb-6",
+        "blockquote": "border-l-4 border-gray-300 pl-6 py-2 italic text-gray-700 my-6",
+        "code-inline": "bg-gray-100 text-gray-800 px-2 py-1 rounded text-sm font-mono",
+        "code-block": "bg-gray-900 text-gray-100 p-6 rounded-lg overflow-x-auto my-6 text-sm"
+      }
+    }
+  },
+  /**
+   * Documentation preset with clean, technical styling
+   */
+  docs: {
+    renderer: {
+      format: "tailwind",
+      customClasses: {
+        "heading-1": "text-3xl font-bold border-b border-gray-200 pb-2 mb-6",
+        "heading-2": "text-2xl font-semibold mt-8 mb-4",
+        "heading-3": "text-xl font-medium mt-6 mb-3",
+        "paragraph": "leading-7 mb-4",
+        "code-inline": "bg-blue-50 text-blue-800 px-2 py-1 rounded text-sm font-mono",
+        "code-block": "bg-gray-50 border border-gray-200 p-4 rounded-lg overflow-x-auto my-4 text-sm",
+        "alert": "border border-blue-200 bg-blue-50 text-blue-800 p-4 rounded-lg mb-4"
+      }
+    }
+  },
+  /**
+   * Minimal preset with basic styling
+   */
+  minimal: {
+    renderer: {
+      format: "html",
+      sanitize: true
+    }
+  },
+  /**
+   * Performance preset with minimal processing
+   */
+  fast: {
+    parser: {
+      validateMarkdown: false,
+      maxIterations: 1e3
+    },
+    renderer: {
+      format: "html",
+      sanitize: false
+    }
+  }
+};
+function createEngineWithPreset(presetName, additionalConfig) {
+  const preset = presets[presetName];
+  return new ChangerawrMarkdown({
+    ...preset,
+    ...additionalConfig
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AlertExtension,
@@ -1809,18 +2209,42 @@ var index_default = markdown2;
   MarkdownParser,
   MarkdownRenderer,
   PerformanceTimer,
+  astToJSONString,
+  astToTokens,
+  basicSanitize,
+  compareTokens,
+  createCumEngine,
   createCustomEngine,
   createDebugEngine,
   createEngine,
+  createEngineWithPreset,
   createHTMLEngine,
   createMinimalEngine,
   createTailwindEngine,
+  debounce,
+  deepMerge,
+  defaultTailwindClasses,
   escapeHtml,
   extractDomain,
   generateId,
+  getASTStats,
+  getTokenStats,
+  isBrowser,
+  isNode,
+  isValidUrl,
   markdown,
+  minimalClasses,
+  parseASTFromJSON,
+  parseCum,
   parseMarkdown,
   parseOptions,
+  parseTokensFromJSON,
+  presets,
+  proseClasses,
+  renderCum,
+  renderCumToHtml,
+  renderCumToJson,
+  renderCumToTailwind,
   renderMarkdown,
   renderToAST,
   renderToHTML,
@@ -1830,6 +2254,8 @@ var index_default = markdown2;
   renderToTailwind,
   renderToTailwindWithClasses,
   renderToTailwindWithConfig,
-  sanitizeHtml
+  sanitizeHtml,
+  tokensToAST,
+  tokensToJSONString
 });
 //# sourceMappingURL=index.js.map