@aigne/doc-smith 0.2.6 → 0.2.9

package/utils/file-utils.mjs

@@ -0,0 +1,205 @@
+import { access, readFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { glob } from "glob";
+
+/**
+ * Check if a directory is inside a git repository using git command
+ * @param {string} dir - Directory path to check
+ * @returns {boolean} True if inside a git repository
+ */
+function isInGitRepository(dir) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd: dir,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find git repository root directory using git command
+ * @param {string} startDir - Starting directory path
+ * @returns {string|null} Git repository root path or null if not found
+ */
+function findGitRoot(startDir) {
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      cwd: startDir,
+      stdio: "pipe",
+      encoding: "utf8",
+    }).trim();
+    return gitRoot;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert gitignore patterns to glob-compatible patterns
+ * @param {string} pattern - A single gitignore pattern
+ * @returns {string[]} Array of glob patterns that match gitignore behavior
+ */
+function gitignoreToGlobPatterns(pattern) {
+  const patterns = [];
+
+  // Remove leading slash (already handled by gitignore parsing)
+  const cleanPattern = pattern.replace(/^\//, "");
+
+  // If pattern doesn't contain wildcards and doesn't end with /
+  // it could match both files and directories
+  if (!cleanPattern.includes("*") && !cleanPattern.includes("?") && !cleanPattern.endsWith("/")) {
+    // Add patterns to match both file and directory
+    patterns.push(cleanPattern); // Exact match
+    patterns.push(`${cleanPattern}/**`); // Directory contents
+    patterns.push(`**/${cleanPattern}`); // Nested exact match
+    patterns.push(`**/${cleanPattern}/**`); // Nested directory contents
+  } else if (cleanPattern.endsWith("/")) {
+    // Directory-only pattern
+    const dirPattern = cleanPattern.slice(0, -1);
+    patterns.push(`${dirPattern}/**`);
+    patterns.push(`**/${dirPattern}/**`);
+  } else {
+    // Pattern with wildcards or specific file
+    patterns.push(cleanPattern);
+    if (!cleanPattern.startsWith("**/")) {
+      patterns.push(`**/${cleanPattern}`);
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Parse .gitignore content into patterns
+ * @param {string} content - .gitignore file content
+ * @returns {string[]} Array of ignore patterns converted to glob format
+ */
+function parseGitignoreContent(content) {
+  const lines = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"))
+    .map((line) => line.replace(/^\//, "")); // Remove leading slash
+
+  // Convert each gitignore pattern to glob patterns
+  const allPatterns = [];
+  for (const line of lines) {
+    allPatterns.push(...gitignoreToGlobPatterns(line));
+  }
+
+  return [...new Set(allPatterns)]; // Remove duplicates
+}
+
+/**
+ * Load .gitignore patterns from multiple directories (current + all parent directories up to git root)
+ * @param {string} dir - Directory path (will search up to find all .gitignore files)
+ * @returns {string[]|null} Array of merged ignore patterns or null if no .gitignore found
+ */
+export async function loadGitignore(dir) {
+  // First, check if we're in a git repository
+  const inGitRepo = isInGitRepository(dir);
+  if (!inGitRepo) {
+    // Not in a git repository, just check the current directory
+    const gitignorePath = path.join(dir, ".gitignore");
+    try {
+      await access(gitignorePath);
+      const gitignoreContent = await readFile(gitignorePath, "utf8");
+      const ignorePatterns = parseGitignoreContent(gitignoreContent);
+      return ignorePatterns.length > 0 ? ignorePatterns : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // We're in a git repository, collect all .gitignore files from current dir to git root
+  const gitRoot = findGitRoot(dir);
+  if (!gitRoot) {
+    return null;
+  }
+
+  const allPatterns = [];
+  let currentDir = path.resolve(dir);
+
+  // Collect .gitignore patterns from current directory up to git root
+  while (currentDir.startsWith(gitRoot)) {
+    const gitignorePath = path.join(currentDir, ".gitignore");
+    try {
+      await access(gitignorePath);
+      const gitignoreContent = await readFile(gitignorePath, "utf8");
+      const patterns = parseGitignoreContent(gitignoreContent);
+
+      // Add patterns with context of which directory they came from
+      // Patterns from deeper directories take precedence
+      allPatterns.unshift(...patterns);
+    } catch {
+      // .gitignore doesn't exist in this directory, continue
+    }
+
+    // Move up one directory
+    if (currentDir === gitRoot) {
+      break;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return allPatterns.length > 0 ? [...new Set(allPatterns)] : null;
+}
+
+/**
+ * Get files using glob patterns
+ * @param {string} dir - Directory to search
+ * @param {string[]} includePatterns - Include patterns
+ * @param {string[]} excludePatterns - Exclude patterns
+ * @param {string[]} gitignorePatterns - .gitignore patterns
+ * @returns {Promise<string[]>} Array of file paths
+ */
+export async function getFilesWithGlob(dir, includePatterns, excludePatterns, gitignorePatterns) {
+  // Prepare all ignore patterns
+  const allIgnorePatterns = [];
+
+  if (excludePatterns) {
+    allIgnorePatterns.push(...excludePatterns);
+  }
+
+  if (gitignorePatterns) {
+    allIgnorePatterns.push(...gitignorePatterns);
+  }
+
+  // Add default exclusions if not already present
+  const defaultExclusions = ["node_modules/**", "test/**", "temp/**"];
+  for (const exclusion of defaultExclusions) {
+    if (!allIgnorePatterns.includes(exclusion)) {
+      allIgnorePatterns.push(exclusion);
+    }
+  }
+
+  // Convert patterns to be relative to the directory
+  const patterns = includePatterns.map((pattern) => {
+    // If pattern doesn't start with / or **, make it relative to dir
+    if (!pattern.startsWith("/") && !pattern.startsWith("**")) {
+      return `**/${pattern}`; // Use ** to search recursively
+    }
+    return pattern;
+  });
+
+  try {
+    const files = await glob(patterns, {
+      cwd: dir,
+      ignore: allIgnorePatterns.length > 0 ? allIgnorePatterns : undefined,
+      absolute: true,
+      nodir: true, // Only return files, not directories
+      dot: false, // Don't include dot files by default
+      gitignore: true, // Enable .gitignore support
+    });
+
+    return files;
+  } catch (error) {
+    console.warn(`Warning: Error during glob search in ${dir}: ${error.message}`);
+    return [];
+  }
+}

package/utils/markdown-checker.mjs

@@ -1,9 +1,9 @@
-import { unified } from "unified";
-import remarkParse from "remark-parse";
 import remarkGfm from "remark-gfm";
 import remarkLint from "remark-lint";
-import { VFile } from "vfile";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
 import { visit } from "unist-util-visit";
+import { VFile } from "vfile";
 import { validateMermaidSyntax } from "./mermaid-validator.mjs";
 
 /**
@@ -16,10 +16,7 @@ function countTableColumns(line) {
   const trimmed = line.trim();
 
   // Remove leading and trailing pipes if present
-  const content =
-    trimmed.startsWith("|") && trimmed.endsWith("|")
-      ? trimmed.slice(1, -1)
-      : trimmed;
+  const content = trimmed.startsWith("|") && trimmed.endsWith("|") ? trimmed.slice(1, -1) : trimmed;
 
   if (!content.trim()) {
     return 0;
@@ -65,7 +62,7 @@ function countTableColumns(line) {
  * @param {Array} errorMessages - Array to push error messages to
  */
 function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
-  const linkRegex = /(?<!\!)\[([^\]]+)\]\(([^)]+)\)/g;
+  const linkRegex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
   let match;
 
   while ((match = linkRegex.exec(markdown)) !== null) {
@@ -77,7 +74,7 @@ function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
     if (/^(https?:\/\/|mailto:)/.test(trimLink)) continue;
 
     // Preserve anchors
-    const [path, hash] = trimLink.split("#");
+    const [path, _hash] = trimLink.split("#");
 
     // Only process relative paths or paths starting with /
     if (!path) continue;
@@ -85,7 +82,89 @@ function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
     // Check if this link is in the allowed links set
     if (!allowedLinks.has(trimLink)) {
       errorMessages.push(
-        `Found a dead link in ${source}: [${match[1]}](${trimLink}), ensure the link exists in the structure plan path`
+        `Found a dead link in ${source}: [${match[1]}](${trimLink}), ensure the link exists in the structure plan path`,
+      );
+    }
+  }
+}
+
+/**
+ * Check code block content for indentation consistency issues
+ * @param {Array} codeBlockContent - Array of {line, lineNumber} objects from the code block
+ * @param {string} source - Source description for error reporting
+ * @param {Array} errorMessages - Array to push error messages to
+ */
+function checkCodeBlockIndentation(codeBlockContent, source, errorMessages) {
+  if (codeBlockContent.length === 0) return;
+
+  // Filter out empty lines for base indentation calculation
+  const nonEmptyLines = codeBlockContent.filter((item) => item.line.trim().length > 0);
+  if (nonEmptyLines.length === 0) return;
+
+  // Find the base indentation from the first meaningful line
+  let baseCodeIndent = null;
+  const problematicLines = [];
+
+  for (const item of nonEmptyLines) {
+    const { line, lineNumber } = item;
+    const match = line.match(/^(\s*)/);
+    const currentIndent = match ? match[1].length : 0;
+    const trimmedLine = line.trim();
+
+    // Skip lines that are clearly comments (common pattern: # comment)
+    if (trimmedLine.startsWith("#") && !trimmedLine.includes("=") && !trimmedLine.includes("{")) {
+      continue;
+    }
+
+    // Establish base indentation from the first meaningful line
+    if (baseCodeIndent === null) {
+      baseCodeIndent = currentIndent;
+      continue;
+    }
+
+    // Check if current line has less indentation than the base
+    // This indicates inconsistent indentation that may cause rendering issues
+    if (currentIndent < baseCodeIndent && baseCodeIndent > 0) {
+      problematicLines.push({
+        lineNumber,
+        line: line.trimEnd(),
+        currentIndent,
+        baseIndent: baseCodeIndent,
+      });
+    }
+  }
+
+  // Report indentation issues if found
+  if (problematicLines.length > 0) {
+    // Group consecutive issues to avoid spam
+    const groupedIssues = [];
+    let currentGroup = [problematicLines[0]];
+
+    for (let i = 1; i < problematicLines.length; i++) {
+      const current = problematicLines[i];
+      const previous = problematicLines[i - 1];
+
+      if (current.lineNumber - previous.lineNumber <= 2) {
+        currentGroup.push(current);
+      } else {
+        groupedIssues.push(currentGroup);
+        currentGroup = [current];
+      }
+    }
+    groupedIssues.push(currentGroup);
+
+    // Report the most significant groups
+    for (const group of groupedIssues.slice(0, 2)) {
+      // Limit to avoid spam
+      const firstIssue = group[0];
+      const lineNumbers =
+        group.length > 1
+          ? `lines ${group[0].lineNumber}-${group[group.length - 1].lineNumber}`
+          : `line ${firstIssue.lineNumber}`;
+
+      const issue = `inconsistent indentation: ${firstIssue.currentIndent} spaces (base: ${firstIssue.baseIndent} spaces)`;
+      errorMessages.push(
+        `Found code block with inconsistent indentation in ${source} at ${lineNumbers}: ${issue}. This may cause rendering issues`,
       );
     }
   }
@@ -103,10 +182,9 @@ function checkContentStructure(markdown, source, errorMessages) {
 
   // State variables for different checks
   let inCodeBlock = false;
-  let codeBlockIndentLevel = 0;
-  let codeBlockStartLine = 0;
   let inAnyCodeBlock = false;
   let anyCodeBlockStartLine = 0;
+  let codeBlockContent = [];
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -118,17 +196,28 @@ function checkContentStructure(markdown, source, errorMessages) {
         // Starting a new code block
         inAnyCodeBlock = true;
         anyCodeBlockStartLine = lineNumber;
+        inCodeBlock = true;
+        codeBlockContent = [];
       } else {
         // Ending the code block
         inAnyCodeBlock = false;
+
+        if (inCodeBlock) {
+          // Check code block content for indentation issues
+          checkCodeBlockIndentation(codeBlockContent, source, errorMessages);
+          inCodeBlock = false;
+        }
       }
+    } else if (inCodeBlock) {
+      // Collect code block content for indentation analysis
+      codeBlockContent.push({ line, lineNumber });
     }
   }
 
   // Check for incomplete code blocks (started but not closed)
   if (inAnyCodeBlock) {
     errorMessages.push(
-      `Found incomplete code block in ${source} starting at line ${anyCodeBlockStartLine}: code block opened with \`\`\` but never closed. Please return the complete content`
+      `Found incomplete code block in ${source} starting at line ${anyCodeBlockStartLine}: code block opened with \`\`\` but never closed. Please return the complete content`,
     );
   }
 
@@ -136,19 +225,15 @@ function checkContentStructure(markdown, source, errorMessages) {
   const newlineCount = (markdown.match(/\n/g) || []).length;
   if (newlineCount === 0 && markdown.trim().length > 0) {
     errorMessages.push(
-      `Found single line content in ${source}: content appears to be on only one line, check for missing line breaks`
+      `Found single line content in ${source}: content appears to be on only one line, check for missing line breaks`,
     );
   }
 
   // Check if content ends with proper punctuation (indicating completeness)
   const trimmedText = markdown.trim();
-  if (
-    trimmedText.length > 0 &&
-    !trimmedText.endsWith(".") &&
-    !trimmedText.endsWith("。")
-  ) {
+  if (trimmedText.length > 0 && !trimmedText.endsWith(".") && !trimmedText.endsWith("。")) {
     errorMessages.push(
-      `Found incomplete content in ${source}: content does not end with proper punctuation (. or 。). Please return the complete content`
+      `Found incomplete content in ${source}: content does not end with proper punctuation (. or 。). Please return the complete content`,
     );
   }
 }
@@ -161,11 +246,7 @@ function checkContentStructure(markdown, source, errorMessages) {
  * @param {Array} [options.allowedLinks] - Set of allowed links for link validation
  * @returns {Promise<Array<string>>} - Array of error messages in check-detail-result format
  */
-export async function checkMarkdown(
-  markdown,
-  source = "content",
-  options = {}
-) {
+export async function checkMarkdown(markdown, source = "content", options = {}) {
   const file = new VFile({ value: markdown, path: source });
   const errorMessages = [];
 
@@ -224,15 +305,14 @@ export async function checkMarkdown(
         // Check for mermaid syntax errors
         mermaidChecks.push(
           validateMermaidSyntax(node.value).catch((error) => {
-            const errorMessage =
-              error?.message || String(error) || "Unknown mermaid syntax error";
+            const errorMessage = error?.message || String(error) || "Unknown mermaid syntax error";
 
             // Format mermaid error in check-detail-result style
             const line = node.position?.start?.line || "unknown";
             errorMessages.push(
-              `Found Mermaid syntax error in ${source} at line ${line}: ${errorMessage}`
+              `Found Mermaid syntax error in ${source} at line ${line}: ${errorMessage}`,
             );
-          })
+          }),
         );
 
         // Check for specific mermaid rendering issues
@@ -240,38 +320,31 @@ export async function checkMarkdown(
         const line = node.position?.start?.line || "unknown";
 
         // Check for backticks in node labels
-        const nodeLabelRegex =
-          /[A-Za-z0-9_]+\["([^"]*`[^"]*)"\]|[A-Za-z0-9_]+{"([^}]*`[^}]*)"}/g;
+        const nodeLabelRegex = /[A-Za-z0-9_]+\["([^"]*`[^"]*)"\]|[A-Za-z0-9_]+{"([^}]*`[^}]*)"}/g;
         let match;
         while ((match = nodeLabelRegex.exec(mermaidContent)) !== null) {
           const label = match[1] || match[2];
           errorMessages.push(
-            `Found backticks in Mermaid node label in ${source} at line ${line}: "${label}" - backticks in node labels cause rendering issues in Mermaid diagrams`
+            `Found backticks in Mermaid node label in ${source} at line ${line}: "${label}" - backticks in node labels cause rendering issues in Mermaid diagrams`,
           );
         }
 
         // Check for numbered list format in edge descriptions
         const edgeDescriptionRegex = /--\s*"([^"]*)"\s*-->/g;
         let edgeMatch;
-        while (
-          (edgeMatch = edgeDescriptionRegex.exec(mermaidContent)) !== null
-        ) {
+        while ((edgeMatch = edgeDescriptionRegex.exec(mermaidContent)) !== null) {
           const description = edgeMatch[1];
           if (/^\d+\.\s/.test(description)) {
             errorMessages.push(
-              `Unsupported markdown: list - Found numbered list format in Mermaid edge description in ${source} at line ${line}: "${description}" - numbered lists in edge descriptions are not supported`
+              `Unsupported markdown: list - Found numbered list format in Mermaid edge description in ${source} at line ${line}: "${description}" - numbered lists in edge descriptions are not supported`,
             );
           }
         }
 
         // Check for special characters in node labels that should be quoted
-        const nodeWithSpecialCharsRegex =
-          /([A-Za-z0-9_]+)\[([^\]]*[(){}:;,\-\s\.][^\]]*)\]/g;
+        const nodeWithSpecialCharsRegex = /([A-Za-z0-9_]+)\[([^\]]*[(){}:;,\-\s.][^\]]*)\]/g;
         let specialCharMatch;
-        while (
-          (specialCharMatch =
-            nodeWithSpecialCharsRegex.exec(mermaidContent)) !== null
-        ) {
+        while ((specialCharMatch = nodeWithSpecialCharsRegex.exec(mermaidContent)) !== null) {
           const nodeId = specialCharMatch[1];
           const label = specialCharMatch[2];
 
@@ -279,15 +352,13 @@ export async function checkMarkdown(
           if (!/^".*"$/.test(label)) {
             // List of characters that typically need quoting
             const specialChars = ["(", ")", "{", "}", ":", ";", ",", "-", "."];
-            const foundSpecialChars = specialChars.filter((char) =>
-              label.includes(char)
-            );
+            const foundSpecialChars = specialChars.filter((char) => label.includes(char));
 
             if (foundSpecialChars.length > 0) {
               errorMessages.push(
                 `Found unquoted special characters in Mermaid node label in ${source} at line ${line}: "${label}" contains ${foundSpecialChars.join(
-                  ", "
-                )} - node labels with special characters should be quoted like ${nodeId}["${label}"]`
+                  ", ",
+                )} - node labels with special characters should be quoted like ${nodeId}["${label}"]`,
               );
             }
           }
@@ -317,7 +388,7 @@ export async function checkMarkdown(
               errorMessages.push(
                 `Found table separator with mismatched column count in ${source} at line ${
                   i + 1
-                }: separator has ${separatorColumns} columns but header has ${headerColumns} columns - this causes table rendering issues`
+                }: separator has ${separatorColumns} columns but header has ${headerColumns} columns - this causes table rendering issues`,
               );
             }
 
@@ -330,7 +401,7 @@ export async function checkMarkdown(
                   errorMessages.push(
                     `Found table data row with mismatched column count in ${source} at line ${
                       i + 2
-                    }: data row has ${dataColumns} columns but separator defines ${separatorColumns} columns - this causes table rendering issues`
+                    }: data row has ${dataColumns} columns but separator defines ${separatorColumns} columns - this causes table rendering issues`,
                   );
                 }
               }
@@ -349,7 +420,7 @@ export async function checkMarkdown(
     // Format messages in check-detail-result style
     file.messages.forEach((message) => {
       const line = message.line || "unknown";
-      const column = message.column || "unknown";
+      const _column = message.column || "unknown";
       const reason = message.reason || "Unknown markdown issue";
       const ruleId = message.ruleId || message.source || "markdown";
 
@@ -366,21 +437,17 @@ export async function checkMarkdown(
       // Format error message similar to check-detail-result style
       if (line !== "unknown") {
         errorMessages.push(
-          `Found ${errorType} issue in ${source} at line ${line}: ${reason} (${ruleId})`
+          `Found ${errorType} issue in ${source} at line ${line}: ${reason} (${ruleId})`,
         );
       } else {
-        errorMessages.push(
-          `Found ${errorType} issue in ${source}: ${reason} (${ruleId})`
-        );
+        errorMessages.push(`Found ${errorType} issue in ${source}: ${reason} (${ruleId})`);
       }
     });
 
     return errorMessages;
   } catch (error) {
     // Handle any unexpected errors during processing
-    errorMessages.push(
-      `Found markdown processing error in ${source}: ${error.message}`
-    );
+    errorMessages.push(`Found markdown processing error in ${source}: ${error.message}`);
     return errorMessages;
   }
 }

package/utils/mermaid-validator.mjs

@@ -3,10 +3,7 @@
  * Provides concurrent-safe validation with isolated worker environments
  */
 
-import {
-  getMermaidWorkerPool,
-  shutdownMermaidWorkerPool,
-} from "./mermaid-worker-pool.mjs";
+import { getMermaidWorkerPool, shutdownMermaidWorkerPool } from "./mermaid-worker-pool.mjs";
 
 /**
  * Worker-based mermaid validation - DEPRECATED but kept for compatibility
@@ -55,17 +52,15 @@ export function validateBasicMermaidSyntax(content) {
   ];
 
   const firstLine = trimmedContent.split("\n")[0].trim();
-  const hasValidType = validDiagramTypes.some((type) =>
-    firstLine.includes(type)
-  );
+  const hasValidType = validDiagramTypes.some((type) => firstLine.includes(type));
 
   if (!hasValidType) {
     throw new Error("Invalid or missing diagram type");
   }
 
   // Basic bracket matching
-  const openBrackets = (content.match(/[\[\{\(]/g) || []).length;
-  const closeBrackets = (content.match(/[\]\}\)]/g) || []).length;
+  const openBrackets = (content.match(/[[{(]/g) || []).length;
+  const closeBrackets = (content.match(/[\]})]/g) || []).length;
 
   if (openBrackets !== closeBrackets) {
     throw new Error("Unmatched brackets in diagram");
@@ -125,7 +120,7 @@ export async function validateMermaidSyntax(content) {
       // Fall back to basic validation for environment issues
       console.warn(
         "Worker-based mermaid validation failed, falling back to basic validation:",
-        errorMsg
+        errorMsg,
       );
       return validateBasicMermaidSyntax(content);
     }

package/utils/mermaid-worker-pool.mjs

@@ -5,9 +5,9 @@
  * Manages worker threads for concurrent mermaid validation
  */
 
-import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -51,18 +51,14 @@ class SimpleMermaidWorkerPool {
         // Handle worker errors more gracefully
         worker.on("error", (error) => {
           if (worker.currentRequest) {
-            worker.currentRequest.reject(
-              new Error(`Worker error: ${error.message}`)
-            );
+            worker.currentRequest.reject(new Error(`Worker error: ${error.message}`));
             worker.currentRequest = null;
           }
         });
 
-        worker.on("exit", (code) => {
+        worker.on("exit", (_code) => {
           if (worker.currentRequest) {
-            worker.currentRequest.reject(
-              new Error("Worker exited unexpectedly")
-            );
+            worker.currentRequest.reject(new Error("Worker exited unexpectedly"));
             worker.currentRequest = null;
           }
         });
@@ -212,7 +208,7 @@ class SimpleMermaidWorkerPool {
     const terminationPromises = this.workers.map(async (worker) => {
       try {
         await worker.terminate();
-      } catch (error) {
+      } catch (_error) {
         // Ignore termination errors
       }
     });