@kenjura/ursa 0.10.0 → 0.33.0

package/src/helper/automenu.js

@@ -1,69 +1,229 @@
 import dirTree from "directory-tree";
-import { extname, basename } from "path";
+import { extname, basename, join, dirname } from "path";
+import { existsSync } from "fs";
 
-export async function getAutomenu(source) {
-  const tree = dirTree(source);
-  const menuItems = [];
+// Icon extensions to check for custom icons
+const ICON_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico'];
 
-  /** order of menu items:
-   *  - Home
-   *  - Top-level folders A-Z
-   *  - Top-level files A-Z
-   **/
+// Default icons (using emoji for simplicity, can be replaced with SVG)
+const FOLDER_ICON = '📁';
+const DOCUMENT_ICON = '📄';
+const HOME_ICON = '🏠';
 
-  menuItems.push({
-    path: "/",
-    name: "Home",
-    type: "file",
-  });
+// Index file extensions to check for folder links
+const INDEX_EXTENSIONS = ['.md', '.txt', '.yml', '.yaml'];
 
-  const topLevelItems = tree.children.sort(childSorter);
-  const topLevelHtml = topLevelItems
-    .map((item) => renderMenuItem({ ...item, source }))
-    .join("");
+function hasIndexFile(dirPath) {
+  for (const ext of INDEX_EXTENSIONS) {
+    const indexPath = join(dirPath, `index${ext}`);
+    if (existsSync(indexPath)) {
+      return true;
+    }
+  }
+  return false;
+}
 
-  return `<ul>${topLevelHtml}</ul>`;
+function findCustomIcon(dirPath, source) {
+  for (const ext of ICON_EXTENSIONS) {
+    const iconPath = join(dirPath, `icon${ext}`);
+    if (existsSync(iconPath)) {
+      // Return the web-accessible path
+      return iconPath.replace(source, '/');
+    }
+  }
+  return null;
 }
 
-function renderMenuItem({ path, name, children, source }) {
-  const ext = extname(path);
-  const href = path.replace(source, "").replace(ext, "");
-  const label = basename(path, ext);
-  //   const childMenuItems = Array.isArray(children)
-  //     ? children
-  //         .map((child) => renderMenuItem({ ...child, source }))
-  //         .sort(menuItemSorter)
-  //     : null;
-  const html = `
-<li data-has-children="${!!children}">
-  <a href="/${href}">${label}</a>
-  ${
-    children
-      ? `<ul>
-    ${children
-      .sort(childSorter)
-      .map((child) => renderMenuItem({ ...child, source }))
-      .join("")}
-  </ul>`
-      : ""
+function getIcon(item, source, isHome = false) {
+  if (isHome) {
+    return `<span class="menu-icon">${HOME_ICON}</span>`;
   }
-</li>`;
-  return html;
+  
+  if (item.children) {
+    // It's a folder - check for custom icon
+    const customIcon = findCustomIcon(item.path, source);
+    if (customIcon) {
+      return `<span class="menu-icon"><img src="${customIcon}" alt="" /></span>`;
+    }
+    return `<span class="menu-icon">${FOLDER_ICON}</span>`;
+  }
+  
+  // It's a file - check for custom icon in parent directory with matching name
+  const dir = dirname(item.path);
+  const base = basename(item.path, extname(item.path));
+  for (const ext of ICON_EXTENSIONS) {
+    const iconPath = join(dir, `${base}-icon${ext}`);
+    if (existsSync(iconPath)) {
+      return `<span class="menu-icon"><img src="${iconPath.replace(source, '/')}" alt="" /></span>`;
+    }
+  }
+  
+  return `<span class="menu-icon">${DOCUMENT_ICON}</span>`;
+}
+
+/**
+ * Resolve an href to a valid .html file path, checking against validPaths.
+ * Returns { href, inactive, debug } where inactive is true if the link doesn't resolve to a valid path.
+ * 
+ * Logic:
+ * - "/" -> "/index.html"
+ * - Any link lacking an extension:
+ *   - Try adding ".html" - if path exists, use it
+ *   - Try adding "/index.html" - if path exists, use it
+ *   - Otherwise, mark as inactive
+ * - Links with extensions are checked directly
+ */
+function resolveHref(rawHref, validPaths) {
+  const debugTries = [];
+  
+  if (!rawHref) {
+    return { href: null, inactive: false, debug: 'null href' };
+  }
+  
+  // Normalize for checking (lowercase)
+  const normalize = (path) => path.toLowerCase();
+  
+  // Root link
+  if (rawHref === '/') {
+    const indexPath = '/index.html';
+    const exists = validPaths.has(normalize(indexPath));
+    debugTries.push(`${indexPath} → ${exists ? '✓' : '✗'}`);
+    if (exists) {
+      return { href: '/index.html', inactive: false, debug: debugTries.join(' | ') };
+    }
+    return { href: '/', inactive: true, debug: debugTries.join(' | ') };
+  }
+  
+  // Check if the link already has an extension
+  const ext = extname(rawHref);
+  if (ext) {
+    // Has extension - check if path exists
+    const exists = validPaths.has(normalize(rawHref));
+    debugTries.push(`${rawHref} → ${exists ? '✓' : '✗'}`);
+    return { href: rawHref, inactive: !exists, debug: debugTries.join(' | ') };
+  }
+  
+  // No extension - try .html first
+  const htmlPath = rawHref + '.html';
+  const htmlExists = validPaths.has(normalize(htmlPath));
+  debugTries.push(`${htmlPath} → ${htmlExists ? '✓' : '✗'}`);
+  if (htmlExists) {
+    return { href: htmlPath, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Try /index.html
+  const indexPath = rawHref + '/index.html';
+  const indexExists = validPaths.has(normalize(indexPath));
+  debugTries.push(`${indexPath} → ${indexExists ? '✓' : '✗'}`);
+  if (indexExists) {
+    return { href: indexPath, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Neither exists - mark as inactive, keep original href
+  return { href: rawHref, inactive: true, debug: debugTries.join(' | ') };
+}
+
+// Build a flat tree structure with path info for JS navigation
+function buildMenuData(tree, source, validPaths, parentPath = '') {
+  const items = [];
+  
+  for (const item of tree.children || []) {
+    const ext = extname(item.path);
+    const label = basename(item.path, ext);
+    const hasChildren = !!item.children;
+    const relativePath = item.path.replace(source, '');
+    const folderPath = parentPath ? `${parentPath}/${label}` : label;
+    
+    let rawHref = null;
+    if (hasChildren) {
+      if (hasIndexFile(item.path)) {
+        // Construct proper path - relativePath already starts with /
+        const cleanPath = relativePath.startsWith('/') ? relativePath : '/' + relativePath;
+        rawHref = `${cleanPath}/index.html`.replace(/\/\//g, '/');
+      }
+    } else {
+      const cleanPath = relativePath.startsWith('/') ? relativePath : '/' + relativePath;
+      rawHref = cleanPath.replace(ext, '');
+    }
+    
+    // Resolve the href and check if target exists
+    const { href, inactive, debug } = resolveHref(rawHref, validPaths);
+    
+    const menuItem = {
+      label,
+      path: folderPath,
+      href,
+      inactive,
+      debug,
+      hasChildren,
+      icon: getIcon(item, source),
+    };
+    
+    if (hasChildren) {
+      menuItem.children = buildMenuData(item, source, validPaths, folderPath);
+    }
+    
+    items.push(menuItem);
+  }
+  
+  return items.sort((a, b) => {
+    if (a.hasChildren && !b.hasChildren) return -1;
+    if (b.hasChildren && !a.hasChildren) return 1;
+    if (a.label > b.label) return 1;
+    if (a.label < b.label) return -1;
+    return 0;
+  });
+}
+
+export async function getAutomenu(source, validPaths) {
+  const tree = dirTree(source, {
+    exclude: /[\/\\]\.|node_modules/,  // Exclude hidden folders (starting with .) and node_modules
+  });
+  const menuData = buildMenuData(tree, source, validPaths);
+  
+  // Add home item with resolved href
+  const homeResolved = resolveHref('/', validPaths);
+  const fullMenuData = [
+    { label: 'Home', path: '', href: homeResolved.href, inactive: homeResolved.inactive, debug: homeResolved.debug, hasChildren: false, icon: `<span class="menu-icon">${HOME_ICON}</span>` },
+    ...menuData
+  ];
+  
+  // Embed the menu data as JSON for JavaScript to use
+  const menuDataScript = `<script type="application/json" id="menu-data">${JSON.stringify(fullMenuData)}</script>`;
+  
+  // Render the breadcrumb header (hidden by default, shown when navigating)
+  const breadcrumbHtml = `
+<div class="menu-breadcrumb" style="display: none;">
+  <button class="menu-back" title="Go back">←</button>
+  <button class="menu-home" title="Go to root">🏠</button>
+  <span class="menu-current-path"></span>
+</div>`;
 
-  return {
-    href,
-    label,
-    childMenuItems,
-  };
+  // Render the initial menu (root level)
+  const menuHtml = renderMenuLevel(fullMenuData, 0);
+  
+  return `${menuDataScript}${breadcrumbHtml}<ul class="menu-level" data-level="0">${menuHtml}</ul>`;
+}
 
-  /**
-   * example output:
-   * {
-   *   href:'Foo/Bar',
-   *   label:'Bar',
-   *   childMenuItems: [thisObject]
-   * }
-   */
+function renderMenuLevel(items, level) {
+  return items.map(item => {
+    const hasChildrenClass = item.hasChildren ? ' has-children' : '';
+    const hasChildrenIndicator = item.hasChildren ? '<span class="menu-more">⋯</span>' : '';
+    const inactiveClass = item.inactive ? ' inactive' : '';
+    
+    const labelHtml = item.href
+      ? `<a href="${item.href}" class="menu-label${inactiveClass}">${item.label}</a>`
+      : `<span class="menu-label">${item.label}</span>`;
+    
+    return `
+<li class="menu-item${hasChildrenClass}" data-path="${item.path}">
+  <div class="menu-item-row">
+    ${item.icon}
+    ${labelHtml}
+    ${hasChildrenIndicator}
+  </div>
+</li>`;
+  }).join('');
 }
 
 function childSorter(a, b) {

package/src/helper/contentHash.js

@@ -0,0 +1,71 @@
+import { createHash } from 'crypto';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+
+const URSA_DIR = '.ursa';
+const HASH_CACHE_FILE = 'content-hashes.json';
+
+/**
+ * Get the path to the .ursa directory for a given source directory
+ */
+export function getUrsaDir(sourceDir) {
+  return join(sourceDir, URSA_DIR);
+}
+
+/**
+ * Generate a short hash of content
+ */
+export function hashContent(content) {
+  return createHash('md5').update(content).digest('hex').substring(0, 12);
+}
+
+/**
+ * Load the hash cache from disk (.ursa folder in source directory)
+ */
+export async function loadHashCache(sourceDir) {
+  const cachePath = join(getUrsaDir(sourceDir), HASH_CACHE_FILE);
+  try {
+    if (existsSync(cachePath)) {
+      const data = await readFile(cachePath, 'utf8');
+      return new Map(Object.entries(JSON.parse(data)));
+    }
+  } catch (e) {
+    console.warn('Could not load hash cache:', e.message);
+  }
+  return new Map();
+}
+
+/**
+ * Save the hash cache to disk (.ursa folder in source directory)
+ */
+export async function saveHashCache(sourceDir, hashMap) {
+  const ursaDir = getUrsaDir(sourceDir);
+  const cachePath = join(ursaDir, HASH_CACHE_FILE);
+  try {
+    await mkdir(ursaDir, { recursive: true });
+    const obj = Object.fromEntries(hashMap);
+    await writeFile(cachePath, JSON.stringify(obj, null, 2));
+    console.log(`Saved ${hashMap.size} hashes to ${cachePath}`);
+  } catch (e) {
+    console.warn('Could not save hash cache:', e.message);
+  }
+}
+
+/**
+ * Check if a file needs regeneration based on content hash
+ */
+export function needsRegeneration(filePath, content, hashCache) {
+  const newHash = hashContent(content);
+  const oldHash = hashCache.get(filePath);
+  return newHash !== oldHash;
+}
+
+/**
+ * Update the hash for a file in the cache
+ */
+export function updateHash(filePath, content, hashCache) {
+  const hash = hashContent(content);
+  hashCache.set(filePath, hash);
+  return hash;
+}

package/src/helper/findStyleCss.js

@@ -0,0 +1,26 @@
+import { join, dirname, resolve } from "path";
+import { existsSync } from "fs";
+
+/**
+ * Recursively search for style.css or _style.css up the directory tree.
+ * Returns the contents of the first found file, or null if not found.
+ * @param {string} startDir - Directory to start searching from
+ * @param {string[]} [names=["style.css", "_style.css"]] - Filenames to look for
+ * @param {string} [baseDir] - Stop searching when this directory is reached
+ * @returns {Promise<string|null>} CSS contents or null
+ */
+export async function findStyleCss(startDir, names = ["style-ursa.css", "style.css", "_style.css"], baseDir = null) {
+  let dir = resolve(startDir);
+  baseDir = baseDir ? resolve(baseDir) : dir.split(/[\\/]/)[0] === '' ? '/' : dir.split(/[\\/]/)[0];
+  while (true) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) {
+        return (await import('fs/promises')).readFile(candidate, "utf8");
+      }
+    }
+    if (dir === baseDir || dir === dirname(dir)) break;
+    dir = dirname(dir);
+  }
+  return null;
+}

package/src/helper/linkValidator.js

@@ -0,0 +1,246 @@
+import { extname, dirname, join, normalize, posix } from "path";
+
+/**
+ * Build a set of valid internal paths from the list of source files
+ * @param {string[]} sourceFiles - Array of source file paths
+ * @param {string} source - Source directory path
+ * @returns {Set<string>} Set of valid internal paths (without extension, lowercased)
+ */
+export function buildValidPaths(sourceFiles, source) {
+  const validPaths = new Set();
+  
+  for (const file of sourceFiles) {
+    // Get the path relative to source, without extension
+    const ext = extname(file);
+    let relativePath = file.replace(source, "").replace(ext, "");
+    
+    // Normalize: ensure leading slash, lowercase for comparison
+    if (!relativePath.startsWith("/")) {
+      relativePath = "/" + relativePath;
+    }
+    
+    // Add both with and without trailing slash for directories
+    validPaths.add(relativePath.toLowerCase());
+    validPaths.add((relativePath + ".html").toLowerCase());
+    
+    // Also add /index.html variant for directory indexes
+    if (relativePath.endsWith("/index")) {
+      const dirPath = relativePath.replace(/\/index$/, "");
+      validPaths.add(dirPath.toLowerCase());
+      validPaths.add((dirPath + "/").toLowerCase());
+      validPaths.add((dirPath + "/index.html").toLowerCase());
+    }
+  }
+  
+  // Add root
+  validPaths.add("/");
+  validPaths.add("/index.html");
+  
+  return validPaths;
+}
+
+/**
+ * Check if a link is an internal link (not external)
+ * @param {string} href - The href value
+ * @returns {boolean}
+ */
+function isInternalLink(href) {
+  if (!href) return false;
+  
+  // External links start with http://, https://, //, mailto:, tel:, etc.
+  if (href.match(/^(https?:)?\/\/|^mailto:|^tel:|^javascript:|^#/i)) {
+    return false;
+  }
+  
+  // Data URLs
+  if (href.startsWith("data:")) {
+    return false;
+  }
+  
+  return true;
+}
+
+/**
+ * Check if a link is relative (starts with ./ or ../ or doesn't start with /)
+ * @param {string} href - The href value
+ * @returns {boolean}
+ */
+function isRelativeLink(href) {
+  if (!href) return false;
+  return href.startsWith('./') || href.startsWith('../') || !href.startsWith('/');
+}
+
+/**
+ * Resolve a relative href to an absolute path based on the current document's path
+ * @param {string} href - The relative href
+ * @param {string} currentDocPath - The current document's URL path (e.g., "/character/index.html")
+ * @returns {string} Absolute path
+ */
+function resolveRelativePath(href, currentDocPath) {
+  // Get the directory of the current document
+  const currentDir = posix.dirname(currentDocPath);
+  
+  // Join and normalize
+  const resolved = posix.normalize(posix.join(currentDir, href));
+  
+  return resolved;
+}
+
+/**
+ * Normalize an href for comparison against valid paths
+ * @param {string} href - The href to normalize
+ * @param {string} currentDocPath - The current document's URL path (for relative link resolution)
+ * @returns {string} Normalized path
+ */
+function normalizeHref(href, currentDocPath = null) {
+  // Remove hash fragments
+  let normalized = href.split("#")[0];
+  
+  // Remove query strings
+  normalized = normalized.split("?")[0];
+  
+  // Resolve relative links if we have the current doc path
+  if (currentDocPath && isRelativeLink(normalized)) {
+    normalized = resolveRelativePath(normalized, currentDocPath);
+  }
+  
+  // Ensure leading slash for absolute paths
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  
+  // Decode URI components
+  try {
+    normalized = decodeURIComponent(normalized);
+  } catch (e) {
+    // Ignore decode errors
+  }
+  
+  return normalized.toLowerCase();
+}
+
+/**
+ * Resolve an href to a valid path, trying .html and /index.html extensions.
+ * Returns { resolvedHref, inactive, debug } where:
+ * - resolvedHref is the corrected href (with .html extension if needed)
+ * - inactive is true if the link doesn't resolve to a valid path
+ * - debug contains information about what was tried
+ * 
+ * @param {string} href - The original href
+ * @param {Set<string>} validPaths - Set of valid internal paths (lowercased)
+ * @param {string} currentDocPath - The current document's URL path (for relative link resolution)
+ * @returns {{ resolvedHref: string, inactive: boolean, debug: string }}
+ */
+function resolveHref(href, validPaths, currentDocPath = null) {
+  const debugTries = [];
+  
+  // Get hash fragment if present (to preserve it)
+  const hashIndex = href.indexOf('#');
+  const hash = hashIndex >= 0 ? href.substring(hashIndex) : '';
+  const hrefWithoutHash = hashIndex >= 0 ? href.substring(0, hashIndex) : href;
+  
+  // Normalize for checking (resolve relative paths if currentDocPath provided)
+  const normalized = normalizeHref(hrefWithoutHash, currentDocPath);
+  
+  // Calculate the resolved absolute href (for updating the link)
+  const isRelative = isRelativeLink(hrefWithoutHash);
+  const absoluteHref = isRelative && currentDocPath 
+    ? resolveRelativePath(hrefWithoutHash, currentDocPath)
+    : hrefWithoutHash;
+  
+  // If exact match exists, return resolved absolute path
+  if (validPaths.has(normalized)) {
+    debugTries.push(`${normalized} → ✓ (exact)`);
+    return { resolvedHref: absoluteHref + hash, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Check if the href already has an extension
+  const ext = extname(hrefWithoutHash);
+  if (ext) {
+    // Has extension but doesn't exist
+    debugTries.push(`${normalized} → ✗`);
+    return { resolvedHref: absoluteHref + hash, inactive: true, debug: debugTries.join(' | ') };
+  }
+  
+  // No extension - try .html first
+  const htmlPath = normalized + '.html';
+  debugTries.push(`${htmlPath} → ${validPaths.has(htmlPath) ? '✓' : '✗'}`);
+  if (validPaths.has(htmlPath)) {
+    // Construct the resolved href as absolute path with .html
+    const resolvedHref = absoluteHref + '.html' + hash;
+    return { resolvedHref, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Try /index.html
+  const indexPath = normalized.endsWith('/') 
+    ? normalized + 'index.html' 
+    : normalized + '/index.html';
+  debugTries.push(`${indexPath} → ${validPaths.has(indexPath) ? '✓' : '✗'}`);
+  if (validPaths.has(indexPath)) {
+    // Construct the resolved href as absolute path with /index.html
+    const resolvedHref = (absoluteHref.endsWith('/') 
+      ? absoluteHref + 'index.html' 
+      : absoluteHref + '/index.html') + hash;
+    return { resolvedHref, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Neither exists - mark as inactive, keep absolute href
+  return { resolvedHref: absoluteHref + hash, inactive: true, debug: debugTries.join(' | ') };
+}
+
+/**
+ * Process HTML to resolve internal links and add class="inactive" to broken links.
+ * This both:
+ * 1. Resolves relative links to absolute paths
+ * 2. Resolves extensionless links to .html (e.g., /foo/bar -> /foo/bar.html)
+ * 3. Marks broken links with the "inactive" class
+ * 
+ * @param {string} html - The HTML content
+ * @param {Set<string>} validPaths - Set of valid internal paths
+ * @param {string} currentDocPath - The current document's URL path (e.g., "/character/index.html")
+ * @param {boolean} includeDebug - Whether to include debug info in link text
+ * @returns {string} Processed HTML with resolved links and inactive class on broken links
+ */
+export function markInactiveLinks(html, validPaths, currentDocPath = '/', includeDebug = false) {
+  // Match anchor tags with href attribute
+  // This regex captures: everything before href, the href value, everything after, and the link text
+  return html.replace(/<a\s+([^>]*?)href=["']([^"']+)["']([^>]*)>([^<]*)<\/a>/gi, (match, before, href, after, text) => {
+    // Skip external links
+    if (!isInternalLink(href)) {
+      return match;
+    }
+    
+    // Resolve the href (passing current doc path for relative link resolution)
+    const { resolvedHref, inactive, debug } = resolveHref(href, validPaths, currentDocPath);
+    
+    // Build the class attribute
+    let newBefore = before;
+    let newAfter = after;
+    
+    if (inactive) {
+      // Check if class already exists in before or after
+      const classInBefore = before.match(/class=["']([^"']*)["']/i);
+      const classInAfter = after.match(/class=["']([^"']*)["']/i);
+      
+      if (classInBefore) {
+        const existingClass = classInBefore[1];
+        if (!existingClass.includes('inactive')) {
+          newBefore = before.replace(classInBefore[0], `class="${existingClass} inactive"`);
+        }
+      } else if (classInAfter) {
+        const existingClass = classInAfter[1];
+        if (!existingClass.includes('inactive')) {
+          newAfter = after.replace(classInAfter[0], `class="${existingClass} inactive"`);
+        }
+      } else {
+        // Add class attribute
+        newBefore = `class="inactive" ${before}`;
+      }
+    }
+    
+    // Add debug text if requested
+    const debugText = includeDebug ? ` [DEBUG: ${debug}]` : '';
+    
+    return `<a ${newBefore}href="${resolvedHref}"${newAfter}>${text}${debugText}</a>`;
+  });
+}

package/src/helper/metadataExtractor.js

@@ -3,6 +3,9 @@ import { parse } from "yaml";
 export function extractMetadata(rawBody) {
   const frontMatter = matchFrontMatter(rawBody);
   if (frontMatter === null) return null;
+  
+  // Don't try to parse empty or whitespace-only content
+  if (frontMatter.trim().length === 0) return null;
 
   const parsedYml = parse(frontMatter);
   return parsedYml;
@@ -16,15 +19,23 @@ export function extractRawMetadata(rawBody) {
 }
 
 function matchFrontMatter(str) {
-  const match = str.match(/---(.*?)---/s);
-  if (Array.isArray(match) && match.length > 1) {
-    return match[1];
-  } else return null;
+  // Only match YAML front matter at the start of the file
+  // Must have --- at line start, content, then closing --- also at line start
+  // The (?=\n|$) ensures the closing --- is followed by newline or end of string
+  const match = str.match(/^---\n([\s\S]+?)\n---(?=\n|$)/);
+  if (!match || match.length < 2) return null;
+  
+  // Return null if the captured content is empty or only whitespace
+  const content = match[1].trim();
+  return content.length > 0 ? match[1] : null;
 }
 
 function matchAllFrontMatter(str) {
-  const match = str.match(/---(.*?)---\n+/s);
-  if (Array.isArray(match) && match.length > 0) {
-    return match[0];
-  } else return null;
+  // Only match YAML front matter at the start of the file
+  const match = str.match(/^---\n([\s\S]+?)\n---(?=\n|$)/);
+  if (!match || match.length < 2) return null;
+  
+  // Check if there's actual content between the delimiters
+  const content = match[1].trim();
+  return content.length > 0 ? match[0] + '\n' : null;
 }