@knowcode/doc-builder 1.9.31 → 1.10.0

package/lib/core-builder.js

@@ -919,10 +919,10 @@ function buildNavigationStructure(files, currentFile, config = {}) {
     return title;
   };
   
-  // Helper function to render a section
+  // OPTIMIZATION: Helper function to render a section using array joins instead of string concatenation
   const renderSection = (folderName, folderData, level = 0, parentPath = '') => {
     const icons = {
-      'root': 'ph ph-caret-down',  // Changed to caret for collapse/expand functionality
+      'root': 'ph ph-caret-down',
       'product-roadmap': 'ph ph-road-horizon',
       'product-requirements': 'ph ph-list-checks',
       'architecture': 'ph ph-tree-structure',
@@ -947,102 +947,95 @@ function buildNavigationStructure(files, currentFile, config = {}) {
       'launch': 'ph ph-rocket-launch',
       'prompts': 'ph ph-chat-circle-dots'
     };
-    
-    const displayName = folderName === 'root' ? 'Documentation' : 
+
+    const displayName = folderName === 'root' ? 'Documentation' :
                        smartCapitalize(folderName);
     const icon = icons[folderName] || 'ph ph-folder';
-    
+
     if (!folderData.files.length && !Object.keys(folderData.folders).length) {
       return '';
     }
-    
+
     // Include parent path in section ID to make it unique
     const pathParts = parentPath ? [parentPath, folderName].join('-') : folderName;
     const sectionId = `nav-${pathParts}-${level}`;
     const isCollapsible = level > 0 || folderName !== 'root';
     const collapseIcon = isCollapsible ? '<i class="ph ph-caret-right collapse-icon"></i>' : '';
-    
+
     // Check if this folder has a README.md file to link to
     const readmeFile = folderData.files.find(f => f.displayName === 'README');
-    const folderLink = readmeFile ? 
-      `href="${config.isStaticOutput ? readmeFile.urlPath : '/' + readmeFile.urlPath}"` : 
+    const folderLink = readmeFile ?
+      `href="${config.isStaticOutput ? readmeFile.urlPath : '/' + readmeFile.urlPath}"` :
       'href="#"';
-    
+
     // Get folder description for tooltip
     const folderDescription = folderDescriptions[folderName] || '';
     const tooltipAttr = folderDescription ? `data-tooltip="${escapeHtml(folderDescription)}"` : '';
-    
+
     // Check if this folder has active child or if we're on index page
     const hasActiveChild = checkActiveChild(folderData, currentFile);
-    // Expand all folders by default on initial page load (index.html or root README)
     const shouldExpand = hasActiveChild || currentFile === 'index.html' || (currentFile === 'README.html' && level === 1);
-    
+
     // Check if this is a private folder
     const isPrivateFolder = folderName === 'private' || parentPath.includes('private');
     const privateClass = isPrivateFolder ? ' private-nav' : '';
-    
-    // Special handling for root folder - make it a toggle-all button
+
+    // OPTIMIZATION: Use array instead of string concatenation
+    const htmlParts = [];
     const isRoot = folderName === 'root' && level === 0;
-    let html = '';
-    
+
     if (isRoot) {
-      // Root gets special toggle-all functionality
-      html = `
+      htmlParts.push(`
       <div class="nav-section${privateClass}" data-level="${level}">
         <a class="nav-title toggle-all-nav expanded" href="#" id="nav-toggle-all" title="Collapse/Expand All">
           <i class="ph ph-caret-down" id="toggle-all-icon"></i> ${displayName}
         </a>
-        <div class="nav-content">`;
+        <div class="nav-content">`);
     } else {
-      // Normal folder rendering
-      html = `
+      htmlParts.push(`
       <div class="nav-section${privateClass}" data-level="${level}">
         <a class="nav-title${isCollapsible ? ' collapsible' : ''}${shouldExpand ? ' expanded' : ''}" ${folderLink} ${isCollapsible ? `data-target="${sectionId}"` : ''} ${tooltipAttr}>
           ${collapseIcon}<i class="${icon}"></i> ${displayName}
         </a>
-        <div class="nav-content${isCollapsible ? (shouldExpand ? '' : ' collapsed') : ''}" ${isCollapsible ? `id="${sectionId}"` : ''}>`; 
+        <div class="nav-content${isCollapsible ? (shouldExpand ? '' : ' collapsed') : ''}" ${isCollapsible ? `id="${sectionId}"` : ''}>`);
     }
-    
+
     // Sort and render files
     const sortedFiles = [...folderData.files].sort((a, b) => {
       if (a.displayName === 'README') return -1;
       if (b.displayName === 'README') return 1;
       return a.displayName.localeCompare(b.displayName);
     });
-    
+
     sortedFiles.forEach(file => {
       const title = generateFileTitle(file, displayName, level);
-      
-      // Check if this file is active
+
       let isActive = '';
       if (currentFile === file.urlPath) {
         isActive = ' active';
       } else if (currentFile === 'index.html' && file.displayName === 'README' && folderName === 'root') {
-        // Mark root README as active when viewing index.html
         isActive = ' active';
       }
-      
-      // Use relative paths for static output
+
       const linkPath = config.isStaticOutput ? file.urlPath : '/' + file.urlPath;
       const tooltip = file.summary ? ` data-tooltip="${escapeHtml(file.summary)}"` : '';
       const icon = getIconForStatus(file.status || 'default', false, config);
-      
-      html += `
-        <a href="${linkPath}" class="nav-item${isActive}"${tooltip}>${icon} ${title}</a>`;
+
+      htmlParts.push(`
+        <a href="${linkPath}" class="nav-item${isActive}"${tooltip}>${icon} ${title}</a>`);
     });
-    
-    html += `</div></div>`;
-    
+
+    htmlParts.push(`</div></div>`);
+
     // Render subfolders AFTER closing the parent section
     Object.keys(folderData.folders)
       .sort()
       .forEach(subFolder => {
-        // Build the path for the subfolder including current folder
         const currentPath = parentPath ? `${parentPath}-${folderName}` : folderName;
-        html += renderSection(subFolder, folderData.folders[subFolder], level + 1, currentPath);
+        htmlParts.push(renderSection(subFolder, folderData.folders[subFolder], level + 1, currentPath));
       });
-    
-    return html;
+
+    return htmlParts.join('');
   };
   
   // Check if this is a flat structure
@@ -1052,58 +1045,57 @@ function buildNavigationStructure(files, currentFile, config = {}) {
     // Generate simple flat navigation for all files in root
     return renderSection('root', { files: tree.files, folders: {} }, 0);
   } else {
-    // Generate hierarchical navigation
-    let nav = '';
-    
+    // OPTIMIZATION: Use array for hierarchical navigation building
+    const navParts = [];
+
     // 1. First render the root Documentation section with Overview
     const readmeFile = tree.files.find(f => f.displayName === 'README');
     if (readmeFile || tree.files.length > 0) {
       const rootFiles = readmeFile ? [readmeFile] : [];
-      nav += renderSection('root', { files: rootFiles, folders: {} }, 0);
+      navParts.push(renderSection('root', { files: rootFiles, folders: {} }, 0));
     }
-    
+
     // 2. Then render all folders alphabetically
     Object.keys(tree.folders)
       .sort()
       .forEach(folderName => {
-        nav += renderSection(folderName, tree.folders[folderName], 1);
+        navParts.push(renderSection(folderName, tree.folders[folderName], 1));
       });
-    
+
     // 3. Finally, add remaining root files to the Documentation section
     const otherRootFiles = tree.files.filter(f => f.displayName !== 'README');
     if (otherRootFiles.length > 0) {
+      const nav = navParts.join('');
       // Find the closing </div></div> of the first nav-section (Documentation)
       const navSections = nav.split('<div class="nav-section"');
-      
+
       if (navSections.length > 1) {
-        // Find the end of the first section's content div
         const firstSection = navSections[1];
         const contentDivEnd = firstSection.indexOf('</div></div>');
-        
+
         if (contentDivEnd !== -1) {
-          let additionalFiles = '';
+          const additionalFilesParts = [];
           otherRootFiles.forEach(file => {
             const title = smartCapitalize(file.displayName);
             let isActive = '';
             if (currentFile === file.urlPath) {
               isActive = ' active';
             }
-            // Use relative paths for static output
             const linkPath = config.isStaticOutput ? file.urlPath : '/' + file.urlPath;
             const tooltip = file.summary ? ` data-tooltip="${escapeHtml(file.summary)}"` : '';
             const icon = getIconForStatus(file.status || 'default', false, config);
-            additionalFiles += `
-        <a href="${linkPath}" class="nav-item${isActive}"${tooltip}>${icon} ${title}</a>`;
+            additionalFilesParts.push(`
+        <a href="${linkPath}" class="nav-item${isActive}"${tooltip}>${icon} ${title}</a>`);
           });
-          
+
           // Reconstruct with additional files inserted
-          navSections[1] = firstSection.slice(0, contentDivEnd) + additionalFiles + firstSection.slice(contentDivEnd);
-          nav = navSections.join('<div class="nav-section"');
+          navSections[1] = firstSection.slice(0, contentDivEnd) + additionalFilesParts.join('') + firstSection.slice(contentDivEnd);
+          return navSections.join('<div class="nav-section"');
         }
       }
     }
-    
-    return nav;
+
+    return navParts.join('');
   }
 }
 
@@ -1119,20 +1111,32 @@ async function processMarkdownFile(filePath, outputPath, allFiles, config, useSt
     .split('/')
     .map(segment => encodeURIComponent(segment))
     .join('/');
-  
+
   // Parse front matter
   const { data: frontMatter, content } = matter(rawContent);
-  
+
   // Extract title - priority: front matter > H1 > filename
   const h1Match = content.match(/^#\s+(.+)$/m);
   const h1Title = h1Match ? h1Match[1] : null;
-  
+
   // Normalize title if needed (e.g., convert all-caps to title case)
   const rawTitle = frontMatter.title || h1Title || fileName;
   const title = config.features?.normalizeTitle !== false ? normalizeTitle(rawTitle) : rawTitle;
-  
+
   // Extract summary for tooltip - priority: front matter > auto-extract
   const summary = frontMatter.description || extractSummary(content);
+
+  // OPTIMIZATION: Update the file entry in allFiles with computed summary and status
+  // This allows navigation tooltips to work even though we defer content loading
+  const fileEntry = allFiles.find(f => f.path === filePath);
+  if (fileEntry) {
+    if (!fileEntry.summary) {
+      fileEntry.summary = summary;
+    }
+    if (!fileEntry.status) {
+      fileEntry.status = detectDocumentStatus(content, frontMatter);
+    }
+  }
   
   // Process content
   const htmlContent = processMarkdownContent(content, config);
@@ -1154,32 +1158,35 @@ async function processMarkdownFile(filePath, outputPath, allFiles, config, useSt
   return { title, urlPath, summary, frontMatter };
 }
 
-// Get all markdown files
-async function getAllMarkdownFiles(dir, baseDir = dir, options = {}) {
-  const files = [];
+// OPTIMIZATION: Unified directory scanner - scans once for both markdown and attachments
+async function scanAllFiles(dir, baseDir = dir, options = {}) {
+  const markdownFiles = [];
+  const attachmentFiles = [];
+  const attachmentTypes = options.attachmentTypes || [];
   const items = await fs.readdir(dir);
-  
+
   for (const item of items) {
     // Skip files with non-printable characters in their names
     if (hasNonPrintableChars(item)) {
       console.log(chalk.yellow(`⚠️  Skipping file with non-printable characters: ${sanitizeFilename(item)}`));
       continue;
     }
-    
+
     const fullPath = path.join(dir, item);
     const stat = await fs.stat(fullPath);
-    
+
     // Skip private directories if excludePrivate is true
     if (stat.isDirectory() && options.excludePrivate && item === 'private') {
       continue;
     }
-    
+
     if (stat.isDirectory() && !item.startsWith('.') && !item.startsWith('_')) {
-      const subFiles = await getAllMarkdownFiles(fullPath, baseDir, options);
-      files.push(...subFiles);
+      const subResult = await scanAllFiles(fullPath, baseDir, options);
+      markdownFiles.push(...subResult.markdownFiles);
+      attachmentFiles.push(...subResult.attachmentFiles);
     } else if (item.endsWith('.md') && !item.startsWith('_')) {
+      // Process markdown files
       const relativePath = path.relative(baseDir, fullPath);
-      // Encode special characters in URL but keep slashes
       const urlPath = relativePath
         .replace(/\.md$/, '.html')
         .replace(/\\/g, '/')
@@ -1187,25 +1194,25 @@ async function getAllMarkdownFiles(dir, baseDir = dir, options = {}) {
         .map(segment => encodeURIComponent(segment))
         .join('/');
       const displayName = smartCapitalize(path.basename(item, '.md'));
-      
-      // Read file to extract summary and status
+
+      // OPTIMIZATION: Only read frontmatter, not full content
+      // Read file but only parse frontmatter, defer content processing
       const rawContent = await fs.readFile(fullPath, 'utf-8');
-      const { data: frontMatter, content } = matter(rawContent);
-      const summary = frontMatter.description || extractSummary(content);
-      const status = detectDocumentStatus(content, frontMatter);
-      
-      
-      // Check if this file is in the private directory
-      const isPrivate = relativePath.split(path.sep)[0] === 'private' || 
-                       relativePath.startsWith('private/') || 
+      const { data: frontMatter } = matter(rawContent, { excerpt: false });
+
+      // Use frontmatter description if available, otherwise defer summary extraction
+      const summary = frontMatter.description || '';
+      const status = frontMatter.status || null;
+
+      const isPrivate = relativePath.split(path.sep)[0] === 'private' ||
+                       relativePath.startsWith('private/') ||
                        relativePath.startsWith('private\\');
-      
-      // Skip private files if excludePrivate is true
+
       if (options.excludePrivate && isPrivate) {
         continue;
       }
-      
-      files.push({
+
+      markdownFiles.push({
         path: fullPath,
         relativePath,
         urlPath,
@@ -1214,39 +1221,21 @@ async function getAllMarkdownFiles(dir, baseDir = dir, options = {}) {
         isPrivate,
         status,
         frontMatter,
-        content
       });
-    }
-  }
-  
-  return files;
-}
-
-// Get all attachment files
-async function getAllAttachmentFiles(dir, baseDir = dir, attachmentTypes) {
-  const files = [];
-  const items = await fs.readdir(dir);
-  
-  for (const item of items) {
-    // Skip files with non-printable characters in their names
-    if (hasNonPrintableChars(item)) {
-      console.log(chalk.yellow(`⚠️  Skipping attachment with non-printable characters: ${sanitizeFilename(item)}`));
-      continue;
-    }
-    
-    const fullPath = path.join(dir, item);
-    const stat = await fs.stat(fullPath);
-    
-    if (stat.isDirectory() && !item.startsWith('.')) {
-      // Recursively scan subdirectories
-      const subFiles = await getAllAttachmentFiles(fullPath, baseDir, attachmentTypes);
-      files.push(...subFiles);
-    } else {
-      // Check if file is an attachment type
+    } else if (attachmentTypes.length > 0) {
+      // Process attachment files
       const ext = path.extname(item).toLowerCase();
       if (attachmentTypes.includes(ext) && !item.startsWith('.')) {
         const relativePath = path.relative(baseDir, fullPath);
-        files.push({
+        const isPrivate = relativePath.split(path.sep)[0] === 'private' ||
+                         relativePath.startsWith('private/') ||
+                         relativePath.startsWith('private\\');
+
+        if (options.excludePrivate && isPrivate) {
+          continue;
+        }
+
+        attachmentFiles.push({
           path: fullPath,
           relativePath,
           size: stat.size
@@ -1254,8 +1243,20 @@ async function getAllAttachmentFiles(dir, baseDir = dir, attachmentTypes) {
       }
     }
   }
-  
-  return files;
+
+  return { markdownFiles, attachmentFiles };
+}
+
+// Get all markdown files (backward compatibility wrapper)
+async function getAllMarkdownFiles(dir, baseDir = dir, options = {}) {
+  const result = await scanAllFiles(dir, baseDir, options);
+  return result.markdownFiles;
+}
+
+// Get all attachment files (backward compatibility wrapper)
+async function getAllAttachmentFiles(dir, baseDir = dir, attachmentTypes) {
+  const result = await scanAllFiles(dir, baseDir, { attachmentTypes });
+  return result.attachmentFiles;
 }
 
 // Copy attachment files to output directory
@@ -1300,10 +1301,26 @@ async function buildDocumentation(config) {
   console.log(chalk.blue('📋 Checking documentation structure...'));
   const readmeGenerated = await createPlaceholderReadme(docsDir, config);
   
-  console.log(chalk.blue('📄 Scanning for markdown files...'));
-  const files = await getAllMarkdownFiles(docsDir);
+  // OPTIMIZATION: Single unified scan for both markdown and attachments
+  console.log(chalk.blue('📄 Scanning documentation directory...'));
+  const attachmentTypes = config.attachmentTypes || [
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.csv', '.ppt', '.pptx', '.txt', '.rtf',
+    '.html', '.htm',
+    '.zip', '.tar', '.gz', '.7z', '.rar',
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.bmp',
+    '.json', '.xml', '.yaml', '.yml', '.toml',
+    '.mp4', '.mp3', '.wav', '.avi', '.mov'
+  ];
+
+  const { markdownFiles: files, attachmentFiles } = await scanAllFiles(docsDir, docsDir, {
+    attachmentTypes: config.features?.attachments !== false ? attachmentTypes : []
+  });
+
   console.log(chalk.green(`✅ Found ${files.length} markdown files${readmeGenerated ? ' (including auto-generated README)' : ''}`));
-  
+  if (config.features?.attachments !== false && attachmentFiles.length > 0) {
+    console.log(chalk.gray(`   Found ${attachmentFiles.length} attachments`));
+  }
+
   // Log the files found
   if (files.length > 0) {
     console.log(chalk.gray('  Found files:'));
@@ -1482,52 +1499,39 @@ async function buildDocumentation(config) {
     }
   }
   
-  // Copy attachment files if feature is enabled
-  if (config.features?.attachments !== false) {
+  // OPTIMIZATION: Use cached attachment files from initial scan
+  if (config.features?.attachments !== false && attachmentFiles.length > 0) {
     console.log(chalk.blue('\n📎 Processing attachments...'));
-    
-    const attachmentTypes = config.attachmentTypes || [
-      '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.csv', '.ppt', '.pptx', '.txt', '.rtf',
-      '.html', '.htm',
-      '.zip', '.tar', '.gz', '.7z', '.rar',
-      '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.bmp',
-      '.json', '.xml', '.yaml', '.yml', '.toml',
-      '.mp4', '.mp3', '.wav', '.avi', '.mov'
-    ];
-    
+
     try {
-      const attachmentFiles = await getAllAttachmentFiles(docsDir, docsDir, attachmentTypes);
-      
-      if (attachmentFiles.length > 0) {
-        const { copiedCount, totalSize } = await copyAttachmentFiles(attachmentFiles, docsDir, outputDir);
-        
-        // Format file size
-        const formatSize = (bytes) => {
-          if (bytes < 1024) return bytes + ' B';
-          if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
-          return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
-        };
-        
-        console.log(chalk.green(`✅ Copied ${copiedCount} attachments (${formatSize(totalSize)} total)`));
-      } else {
-        console.log(chalk.gray('  No attachments found to copy'));
-      }
+      const { copiedCount, totalSize } = await copyAttachmentFiles(attachmentFiles, docsDir, outputDir);
+
+      // Format file size
+      const formatSize = (bytes) => {
+        if (bytes < 1024) return bytes + ' B';
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+        return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+      };
+
+      console.log(chalk.green(`✅ Copied ${copiedCount} attachments (${formatSize(totalSize)} total)`));
     } catch (error) {
       console.warn(chalk.yellow(`Warning: Error processing attachments: ${error.message}`));
     }
+  } else if (config.features?.attachments !== false) {
+    console.log(chalk.gray('  No attachments found to copy'));
   }
   
   // Generate static version if enabled
   if (config.features?.staticOutput !== false) {
     console.log(chalk.blue('\n🌐 Generating static version (no auth, no private content)...'));
-    
+
     const staticOutputDir = path.join(process.cwd(), config.staticOutputDir || 'html-static');
-    
+
     // Ensure static output directory exists
     await fs.ensureDir(staticOutputDir);
-    
-    // Get files excluding private directories
-    const staticFiles = await getAllMarkdownFiles(docsDir, docsDir, { excludePrivate: true });
+
+    // OPTIMIZATION: Filter already-scanned files instead of re-scanning
+    const staticFiles = files.filter(f => !f.isPrivate);
     console.log(chalk.gray(`  Found ${staticFiles.length} public files (private files excluded)`));
     
     // Process files for static output
@@ -1568,27 +1572,13 @@ async function buildDocumentation(config) {
       await fs.writeFile(staticIndexPath, defaultIndex);
     }
     
-    // Copy attachments to static directory if enabled
-    if (config.features?.attachments !== false) {
-      const attachmentTypes = config.attachmentTypes || [
-        '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.csv', '.ppt', '.pptx', '.txt', '.rtf',
-        '.html', '.htm',
-        '.zip', '.tar', '.gz', '.7z', '.rar',
-        '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.bmp',
-        '.json', '.xml', '.yaml', '.yml', '.toml',
-        '.mp4', '.mp3', '.wav', '.avi', '.mov'
-      ];
-      
+    // OPTIMIZATION: Filter already-scanned attachments instead of re-scanning
+    if (config.features?.attachments !== false && attachmentFiles.length > 0) {
       try {
-        // Get attachment files excluding private directories
-        const allAttachmentFiles = await getAllAttachmentFiles(docsDir, docsDir, attachmentTypes);
-        const staticAttachmentFiles = [];
-        for (const file of allAttachmentFiles) {
-          if (!file.relativePath.startsWith('private/') && !file.relativePath.startsWith('private\\')) {
-            staticAttachmentFiles.push(file);
-          }
-        }
-        
+        const staticAttachmentFiles = attachmentFiles.filter(file =>
+          !file.relativePath.startsWith('private/') && !file.relativePath.startsWith('private\\')
+        );
+
         if (staticAttachmentFiles.length > 0) {
           await copyAttachmentFiles(staticAttachmentFiles, docsDir, staticOutputDir);
         }

package/lib/emoji-mapper.js

@@ -280,6 +280,28 @@ const emojiToPhosphor = {
   '🐌': '<i class="ph ph-spiral" aria-label="snail"></i>',
 };
 
+// OPTIMIZATION: Cache the compiled regex pattern
+let cachedEmojiPattern = null;
+
+/**
+ * Get or build the cached emoji pattern
+ * @returns {RegExp} - Compiled emoji matching regex
+ */
+function getEmojiPattern() {
+  if (!cachedEmojiPattern) {
+    // Build regex pattern once with all emoji patterns
+    // Sort by length to match longer emojis first (e.g., ⚠️ before ⚠)
+    cachedEmojiPattern = new RegExp(
+      Object.keys(emojiToPhosphor)
+        .sort((a, b) => b.length - a.length)
+        .map(emoji => emoji.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('|'),
+      'g'
+    );
+  }
+  return cachedEmojiPattern;
+}
+
 /**
  * Replace emojis with Phosphor icons in HTML
  * @param {string} html - The HTML content to process
@@ -289,27 +311,20 @@ const emojiToPhosphor = {
 function replaceEmojisWithIcons(html, config = {}) {
   // Check if feature is enabled - default to true if not explicitly set to false
   if (config.features?.phosphorIcons === false) return html;
-  
+
   // First, protect code blocks and inline code from emoji replacement
   const codeBlocks = [];
   const codePattern = /(<code[^>]*>[\s\S]*?<\/code>|<pre[^>]*>[\s\S]*?<\/pre>)/g;
-  
+
   // Replace code blocks with placeholders
   html = html.replace(codePattern, (match, p1) => {
     const placeholder = `CODE_BLOCK_${codeBlocks.length}`;
     codeBlocks.push(match);
     return placeholder;
   });
-  
-  // Build regex pattern once with all emoji patterns
-  // Sort by length to match longer emojis first (e.g., ⚠️ before ⚠)
-  const emojiPattern = new RegExp(
-    Object.keys(emojiToPhosphor)
-      .sort((a, b) => b.length - a.length)
-      .map(emoji => emoji.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-      .join('|'),
-    'g'
-  );
+
+  // OPTIMIZATION: Use cached emoji pattern
+  const emojiPattern = getEmojiPattern();
   
   // Get weight class if custom weight is specified
   const weightClass = config.features?.phosphorWeight && config.features.phosphorWeight !== 'regular' 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowcode/doc-builder",
-  "version": "1.9.31",
+  "version": "1.10.0",
   "description": "Reusable documentation builder for markdown-based sites with Vercel deployment support",
   "main": "index.js",
   "bin": {