@changerawr/markdown 1.1.5 → 1.1.7

package/dist/react/index.mjs

@@ -5,10 +5,12 @@ import React, { useMemo as useMemo2, useEffect as useEffect2 } from "react";
 import { useState, useCallback, useMemo, useRef, useEffect } from "react";
 
 // src/parser.ts
-var MarkdownParser = class {
+var MarkdownParser = class _MarkdownParser {
+  // Cache compiled regexes
   constructor(config) {
     this.rules = [];
     this.warnings = [];
+    this.compiledPatterns = /* @__PURE__ */ new Map();
     this.config = {
       debugMode: false,
       maxIterations: 1e4,
@@ -18,6 +20,10 @@ var MarkdownParser = class {
   }
   addRule(rule) {
     this.rules.push(rule);
+    this.compiledPatterns.set(
+      rule,
+      new RegExp(rule.pattern.source, rule.pattern.flags.replace("g", ""))
+    );
     this.rules.sort((a, b) => {
       const aFeatureExtension = ["alert", "button", "embed"].includes(a.name);
       const bFeatureExtension = ["alert", "button", "embed"].includes(b.name);
@@ -63,12 +69,20 @@ var MarkdownParser = class {
       iterationCount++;
       let matched = false;
       let bestMatch = null;
+      let nextBestMatchIndex = null;
       for (const rule of this.rules) {
         try {
-          const pattern = new RegExp(rule.pattern.source, rule.pattern.flags.replace("g", ""));
+          const pattern = this.compiledPatterns.get(rule);
           const match = remaining.match(pattern);
           if (match && match.index !== void 0) {
-            const priority = match.index === 0 ? 1e3 : 1e3 - match.index;
+            if (match.index === 0) {
+              bestMatch = { rule, match, priority: 1e3 };
+              break;
+            }
+            if (nextBestMatchIndex === null || match.index < nextBestMatchIndex) {
+              nextBestMatchIndex = match.index;
+            }
+            const priority = 1e3 - match.index;
             if (!bestMatch || priority > bestMatch.priority || priority === bestMatch.priority && match.index < (bestMatch.match.index || 0)) {
               bestMatch = { rule, match, priority };
             }
@@ -115,15 +129,14 @@ var MarkdownParser = class {
         }
       }
       if (!matched) {
-        const char = remaining[0];
-        if (char) {
-          tokens.push({
-            type: "text",
-            content: char,
-            raw: char
-          });
-          remaining = remaining.slice(1);
-        }
+        const chunkSize = nextBestMatchIndex !== null ? nextBestMatchIndex : Math.min(remaining.length, 1e3);
+        const textChunk = remaining.slice(0, chunkSize);
+        tokens.push({
+          type: "text",
+          content: textChunk,
+          raw: textChunk
+        });
+        remaining = remaining.slice(chunkSize);
       }
     }
     if (iterationCount >= maxIterations) {
@@ -205,7 +218,18 @@ var MarkdownParser = class {
   recursivelyParseBlockContent(token) {
     const blockTypes = ["alert", "blockquote", "list-item", "task-item"];
     if (blockTypes.includes(token.type) && token.content && token.content.trim()) {
-      const children = this.parse(token.content);
+      let children;
+      if ((token.type === "list-item" || token.type === "task-item") && this.rules.some((r) => r.name === "list-item")) {
+        const parserWithoutListRule = new _MarkdownParser(this.config);
+        this.rules.forEach((rule) => {
+          if (rule.name !== "list-item" && rule.name !== "task-item") {
+            parserWithoutListRule.addRule(rule);
+          }
+        });
+        children = parserWithoutListRule.parse(token.content);
+      } else {
+        children = this.parse(token.content);
+      }
       return {
         ...token,
         children
@@ -541,6 +565,154 @@ var MarkdownRenderer = class {
   }
 };
 
+// src/cache.ts
+var LRUCache = class {
+  constructor(capacity = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+    if (capacity <= 0) {
+      throw new Error("Cache capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+  }
+  /**
+   * Get a value from the cache
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      entry.timestamp = Date.now();
+      entry.accessCount++;
+      this.hits++;
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+      return entry.value;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Set a value in the cache
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      this.evictLRU();
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      accessCount: 0
+    });
+  }
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * Delete a specific key from the cache
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+  /**
+   * Get the current size of the cache
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const totalRequests = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      capacity: this.capacity,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: totalRequests > 0 ? this.hits / totalRequests : 0,
+      evictions: this.evictions
+    };
+  }
+  /**
+   * Reset cache statistics
+   */
+  resetStats() {
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+  /**
+   * Get all keys in the cache
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Get all values in the cache
+   */
+  values() {
+    return Array.from(this.cache.values()).map((entry) => entry.value);
+  }
+  /**
+   * Update cache capacity and evict if necessary
+   */
+  setCapacity(newCapacity) {
+    if (newCapacity <= 0) {
+      throw new Error("Cache capacity must be greater than 0");
+    }
+    this.capacity = newCapacity;
+    while (this.cache.size > this.capacity) {
+      this.evictLRU();
+    }
+  }
+  /**
+   * Evict the least recently used entry
+   */
+  evictLRU() {
+    const firstKey = this.cache.keys().next().value;
+    if (firstKey !== void 0) {
+      this.cache.delete(firstKey);
+      this.evictions++;
+    }
+  }
+};
+function hashContent(content) {
+  if (content.length > 1e4) {
+    const start = content.slice(0, 1e3);
+    const middle = content.slice(Math.floor(content.length / 2) - 500, Math.floor(content.length / 2) + 500);
+    const end = content.slice(-1e3);
+    const sample = content.length + "|" + start + middle + end;
+    let hash2 = 2166136261;
+    for (let i = 0; i < sample.length; i++) {
+      hash2 ^= sample.charCodeAt(i);
+      hash2 += (hash2 << 1) + (hash2 << 4) + (hash2 << 7) + (hash2 << 8) + (hash2 << 24);
+    }
+    return (hash2 >>> 0).toString(36);
+  }
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return (hash >>> 0).toString(36);
+}
+
 // src/extensions/core/blockquote.ts
 var BlockquoteExtension = {
   name: "blockquote",
@@ -1513,8 +1685,13 @@ function extractVimeoId(url) {
 var ChangerawrMarkdown = class {
   constructor(config) {
     this.extensions = /* @__PURE__ */ new Map();
+    this.parseTime = 0;
+    this.renderTime = 0;
+    this.lastTokenCount = 0;
     this.parser = new MarkdownParser(config?.parser);
     this.renderer = new MarkdownRenderer(config?.renderer);
+    this.parseCache = new LRUCache(100);
+    this.renderCache = new LRUCache(100);
     this.registerCoreExtensions();
     this.registerFeatureExtensions();
     if (config?.extensions) {
@@ -1597,14 +1774,83 @@ var ChangerawrMarkdown = class {
     }
   }
   parse(markdown2) {
-    return this.parser.parse(markdown2);
+    const cacheKey = hashContent(markdown2);
+    const cached = this.parseCache.get(cacheKey);
+    if (cached) {
+      this.lastTokenCount = cached.length;
+      return cached;
+    }
+    const startTime = performance.now();
+    const tokens = this.parser.parse(markdown2);
+    this.parseTime = performance.now() - startTime;
+    this.lastTokenCount = tokens.length;
+    this.parseCache.set(cacheKey, tokens);
+    return tokens;
   }
-  render(tokens) {
-    return this.renderer.render(tokens);
+  render(tokens, cacheKey) {
+    if (cacheKey) {
+      const cached = this.renderCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    const startTime = performance.now();
+    const html = this.renderer.render(tokens);
+    this.renderTime = performance.now() - startTime;
+    if (cacheKey) {
+      this.renderCache.set(cacheKey, html);
+    }
+    return html;
   }
   toHtml(markdown2) {
+    const cacheKey = hashContent(markdown2);
+    const cachedHtml = this.renderCache.get(cacheKey);
+    if (cachedHtml) {
+      return cachedHtml;
+    }
     const tokens = this.parse(markdown2);
-    return this.render(tokens);
+    return this.render(tokens, cacheKey);
+  }
+  /**
+   * Render markdown with performance metrics
+   */
+  toHtmlWithMetrics(markdown2) {
+    const startTotal = performance.now();
+    const parseCacheKey = hashContent(markdown2);
+    const parseCacheHit = this.parseCache.has(parseCacheKey);
+    const html = this.toHtml(markdown2);
+    const totalTime = performance.now() - startTotal;
+    const metrics = {
+      inputSize: markdown2.length,
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      totalTime,
+      tokenCount: this.lastTokenCount,
+      cacheHit: parseCacheHit
+    };
+    return { html, metrics };
+  }
+  /**
+   * Stream-render large documents in chunks for better performance
+   */
+  async toHtmlStreamed(markdown2, options = {}) {
+    const chunkSize = options.chunkSize || 50;
+    const tokens = this.parse(markdown2);
+    const totalTokens = tokens.length;
+    const chunks = [];
+    for (let i = 0; i < tokens.length; i += chunkSize) {
+      const chunkTokens = tokens.slice(i, Math.min(i + chunkSize, tokens.length));
+      const chunkHtml = this.render(chunkTokens);
+      chunks.push(chunkHtml);
+      if (options.onChunk) {
+        options.onChunk({
+          html: chunkHtml,
+          progress: Math.min(i + chunkSize, tokens.length) / totalTokens
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    return chunks.join("");
   }
   getExtensions() {
     return Array.from(this.extensions.keys());
@@ -1618,25 +1864,50 @@ var ChangerawrMarkdown = class {
   getDebugInfo() {
     return {
       warnings: this.getWarnings(),
-      parseTime: 0,
-      renderTime: 0,
-      tokenCount: 0,
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      tokenCount: this.lastTokenCount,
       iterationCount: 0
     };
   }
   getPerformanceMetrics() {
     return {
-      parseTime: 0,
-      renderTime: 0,
-      totalTime: 0,
-      tokenCount: 0
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      totalTime: this.parseTime + this.renderTime,
+      tokenCount: this.lastTokenCount
+    };
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      parse: this.parseCache.getStats(),
+      render: this.renderCache.getStats()
     };
   }
+  /**
+   * Clear all caches
+   */
+  clearCaches() {
+    this.parseCache.clear();
+    this.renderCache.clear();
+  }
+  /**
+   * Update cache capacity
+   */
+  setCacheSize(size) {
+    this.parseCache.setCapacity(size);
+    this.renderCache.setCapacity(size);
+  }
   rebuildParserAndRenderer() {
     const parserConfig = this.parser.getConfig();
     const rendererConfig = this.renderer.getConfig();
     this.parser = new MarkdownParser(parserConfig);
     this.renderer = new MarkdownRenderer(rendererConfig);
+    this.parseCache.clear();
+    this.renderCache.clear();
     const extensionsToRegister = Array.from(this.extensions.values());
     const featureExtensions = extensionsToRegister.filter(
       (ext) => ["alert", "button", "embed"].includes(ext.name)