legal-markdown-js 3.3.2 → 3.3.4

package/dist/{browser-modern-wM0F4Tg1.js → browser-modern-BP5EJrCS.js}

@@ -16720,6 +16720,9 @@ function initializeHeaderState() {
     customLevels: /* @__PURE__ */ new Map()
   };
 }
+function getLevelCssClass(level) {
+  return `legal-header-level-${level}`;
+}
 function processHeader(node, config, state, options) {
   const { noReset, noIndent, debug } = options;
   const level = node.depth;
@@ -16727,6 +16730,29 @@ function processHeader(node, config, state, options) {
   updateHeaderState(level, state, noReset);
   const number = getHeaderNumber(level, state);
   const headerText = formatHeaderText(node, format, number, state, { noIndent, debug });
+  if (!node.data) {
+    node.data = {};
+  }
+  const nodeData = node.data;
+  if (!nodeData.hProperties) {
+    nodeData.hProperties = {};
+  }
+  const cssClass = getLevelCssClass(level);
+  const existingClass = nodeData.hProperties.className;
+  if (existingClass) {
+    if (Array.isArray(existingClass)) {
+      if (!existingClass.includes(cssClass)) {
+        existingClass.push(cssClass);
+      }
+    } else if (typeof existingClass === "string") {
+      const classes = existingClass.split(" ");
+      if (!classes.includes(cssClass)) {
+        nodeData.hProperties.className = [...classes, cssClass];
+      }
+    }
+  } else {
+    nodeData.hProperties.className = cssClass;
+  }
   if (headerText !== null) {
     const hasIndentation = headerText.startsWith("  ");
     if (hasIndentation) {
@@ -16737,6 +16763,7 @@ function processHeader(node, config, state, options) {
   }
   if (debug) {
     console.log(`[remarkHeaders] Processed level ${level} header:`, headerText);
+    console.log(`[remarkHeaders] Added CSS class:`, cssClass);
   }
 }
 function getHeaderFormat(level, config) {
@@ -17055,16 +17082,16 @@ const remarkClauses = (options) => {
     }
     visit(tree, (node) => {
       if (node.type === "text") {
-        processTextNode$2(node, metadata, debug, enableFieldTracking);
+        processTextNode$1(node, metadata, debug, enableFieldTracking);
       } else if (node.type === "html" && "value" in node) {
         processHtmlNode(node, metadata, debug, enableFieldTracking);
       } else if (node.type === "paragraph") {
-        processParagraphNode$2(node, metadata, debug, enableFieldTracking);
+        processParagraphNode$1(node, metadata, debug, enableFieldTracking);
       }
     });
   };
 };
-function processTextNode$2(node, metadata, debug, enableFieldTracking) {
+function processTextNode$1(node, metadata, debug, enableFieldTracking) {
   const originalText = node.value;
   const conditionalBlocks = extractConditionalBlocks(originalText);
   if (debug && originalText.includes("{{#")) {
@@ -17109,10 +17136,10 @@ function processHtmlNode(node, metadata, debug, enableFieldTracking) {
   }
   node.value = processedHtml;
 }
-function processParagraphNode$2(node, metadata, debug, enableFieldTracking) {
+function processParagraphNode$1(node, metadata, debug, enableFieldTracking) {
   node.children.forEach((child) => {
     if (child.type === "text") {
-      processTextNode$2(child, metadata, debug, enableFieldTracking);
+      processTextNode$1(child, metadata, debug, enableFieldTracking);
     }
   });
 }
@@ -17845,14 +17872,14 @@ const remarkMixins = (options) => {
     };
     visit(tree, (node) => {
       if (node.type === "text") {
-        processTextNode$1(node, context);
+        processTextNode(node, context);
       } else if (node.type === "paragraph") {
-        processParagraphNode$1(node, context);
+        processParagraphNode(node, context);
       }
     });
   };
 };
-function processTextNode$1(node, context) {
+function processTextNode(node, context) {
   const originalText = node.value;
   const mixinDirectives = extractMixinDirectives(originalText);
   if (mixinDirectives.length === 0) {
@@ -17869,10 +17896,10 @@ function processTextNode$1(node, context) {
   }
   node.value = processedText;
 }
-function processParagraphNode$1(node, context) {
+function processParagraphNode(node, context) {
   node.children.forEach((child) => {
     if (child.type === "text") {
-      processTextNode$1(child, context);
+      processTextNode(child, context);
     }
   });
 }
@@ -21023,1623 +21050,1795 @@ function checkNestedConflicts(key, importedValue, currentFlat, logOperations) {
   return { hasConflict: false, conflictedField: "" };
 }
 
-function escapeHtmlAttribute$1(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function processTemplateLoops(content, metadata, context, enableFieldTracking = true) {
-  const loopBlocks = findLoopBlocks(content);
-  if (loopBlocks.length === 0) {
-    return content;
-  }
-  let processedContent = content;
-  for (let i = loopBlocks.length - 1; i >= 0; i--) {
-    const loopBlock = loopBlocks[i];
-    const expandedContent = expandLoopBlock(loopBlock, metadata, context, enableFieldTracking);
-    processedContent = processedContent.slice(0, loopBlock.start) + expandedContent + processedContent.slice(loopBlock.end);
+const remarkImports = (options) => {
+  const {
+    basePath = ".",
+    mergeMetadata = true,
+    debug = false,
+    maxDepth = 10,
+    timeoutMs = 3e4,
+    filterReserved = true,
+    validateTypes = true,
+    logImportOperations = false,
+    onMetadataMerged,
+    importStack = []
+  } = options;
+  return async (tree) => {
+    const startTime = Date.now();
+    if (debug) {
+      console.log("[remarkImports] Processing imports with options:", {
+        basePath,
+        mergeMetadata,
+        maxDepth,
+        timeoutMs,
+        filterReserved,
+        validateTypes,
+        currentDepth: importStack.length
+      });
+    }
+    const context = {
+      depth: importStack.length,
+      maxDepth,
+      basePath,
+      mergeMetadata,
+      debug,
+      startTime,
+      timeoutMs,
+      filterReserved,
+      validateTypes,
+      logImportOperations,
+      onMetadataMerged,
+      importStack: [...importStack],
+      contentCache: /* @__PURE__ */ new Map(),
+      importedMetadataList: [],
+      importedFiles: [],
+      accumulatedMetadata: {}
+      // Initialize with empty metadata
+    };
+    const replacements = [];
+    visit(tree, "paragraph", (node, index, parent) => {
+      if (!parent || index === void 0) return;
+      for (const child of node.children) {
+        if (child.type === "text") {
+          const directives = extractImportDirectives(child.value);
+          if (directives.length > 0) {
+            replacements.push({
+              parent,
+              index,
+              nodes: []
+              // Will be filled in later
+            });
+            return SKIP;
+          }
+        }
+      }
+    });
+    for (const replacement of replacements) {
+      const paragraph = replacement.parent.children[replacement.index];
+      const processedNodes = await processParagraphWithImports(paragraph, context);
+      replacement.nodes = processedNodes;
+    }
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const { parent, index, nodes } = replacements[i];
+      parent.children.splice(index, 1, ...nodes);
+    }
+    if (context.mergeMetadata && context.importedMetadataList.length > 0) {
+      const mergedResult = performSequentialMerge(context);
+      tree._importedMetadata = mergedResult.metadata;
+      tree._importStats = mergedResult.stats;
+    }
+  };
+};
+async function processParagraphWithImports(paragraph, context) {
+  const results = [];
+  for (const child of paragraph.children) {
+    if (child.type !== "text") {
+      results.push(child);
+      continue;
+    }
+    const text = child.value;
+    const directives = extractImportDirectives(text);
+    if (directives.length === 0) {
+      results.push(child);
+      continue;
+    }
+    if (context.debug) {
+      console.log(`[remarkImports] Found ${directives.length} import directives`);
+    }
+    let lastIndex = 0;
+    for (const directive of directives) {
+      if (directive.start > lastIndex) {
+        const beforeText = text.substring(lastIndex, directive.start);
+        if (beforeText.trim()) {
+          results.push({
+            type: "text",
+            value: beforeText
+          });
+        }
+      }
+      const importedNodes = await processImportDirectiveToAST(directive, context);
+      results.push(...importedNodes);
+      lastIndex = directive.end;
+    }
+    if (lastIndex < text.length) {
+      const afterText = text.substring(lastIndex);
+      if (afterText.trim()) {
+        results.push({
+          type: "text",
+          value: afterText
+        });
+      }
+    }
   }
-  return processedContent;
+  return results;
 }
-function findLoopBlocks(content) {
-  const loopBlocks = [];
-  const loopPattern = /\{\{#([\w.]+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
-  const conditionalPattern = /\{\{#if\s*([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g;
+function extractImportDirectives(text) {
+  const directives = [];
+  const importRegex = /@import\s+([^\s#]+)(?:#([^\s]+))?/g;
   let match;
-  while ((match = loopPattern.exec(content)) !== null) {
-    const [fullMatch, variable, loopContent] = match;
-    loopBlocks.push({
-      variable,
-      content: loopContent,
-      start: match.index,
-      end: match.index + fullMatch.length,
-      fullMatch
-    });
-  }
-  while ((match = conditionalPattern.exec(content)) !== null) {
-    const [fullMatch, condition, conditionalContent] = match;
-    loopBlocks.push({
-      variable: `if ${condition}`,
-      // Mark as conditional
-      content: conditionalContent,
+  while ((match = importRegex.exec(text)) !== null) {
+    const [fullMatch, filePath, section] = match;
+    directives.push({
+      filePath: filePath.trim(),
+      section: section?.trim(),
       start: match.index,
       end: match.index + fullMatch.length,
       fullMatch
     });
   }
-  return loopBlocks;
+  return directives;
 }
-function expandLoopBlock(loopBlock, metadata, parentContext, enableFieldTracking = true) {
-  const { variable, content } = loopBlock;
-  if (variable.startsWith("if ")) {
-    const condition = variable.substring(3).trim();
-    const conditionValue = evaluateCondition(condition, metadata);
-    fieldTracker.trackField(`if ${condition}`, {
-      value: conditionValue,
-      hasLogic: true,
-      mixinUsed: "conditional"
-    });
-    const elseIndex = content.indexOf("{{else}}");
-    if (elseIndex !== -1) {
-      const ifContent = content.substring(0, elseIndex);
-      const elseContent = content.substring(elseIndex + 8);
-      const selectedContent = conditionValue ? ifContent : elseContent;
-      return processTemplateContent(selectedContent, metadata, parentContext, enableFieldTracking);
-    } else {
-      if (conditionValue) {
-        return processTemplateContent(content, metadata, parentContext, enableFieldTracking);
-      } else {
-        return "";
+async function parseImportedContentToAST(content) {
+  const processor = unified().use(remarkParse);
+  const tree = processor.parse(content);
+  return tree.children;
+}
+async function processImportDirectiveToAST(directive, context) {
+  if (context.depth >= context.maxDepth) {
+    console.warn(
+      `[remarkImports] Maximum import depth (${context.maxDepth}) reached for file "${directive.filePath}"`
+    );
+    return [{ type: "text", value: directive.fullMatch }];
+  }
+  const absolutePath = pathBrowserifyExports.resolve(context.basePath, directive.filePath);
+  const normalizedPath = pathBrowserifyExports.normalize(absolutePath);
+  if (context.importStack.includes(normalizedPath)) {
+    console.warn(`[remarkImports] Circular import detected: ${normalizedPath}`);
+    return [{ type: "text", value: directive.fullMatch }];
+  }
+  if (context.debug) {
+    console.log(
+      `[remarkImports] Processing import "${directive.filePath}" (resolved: ${normalizedPath})`
+    );
+  }
+  const fileContent = loadFileContent(normalizedPath, context);
+  if (!fileContent) {
+    console.warn(`[remarkImports] Import file not found: ${directive.filePath}`);
+    return [{ type: "text", value: directive.fullMatch }];
+  }
+  let contentToImport = fileContent;
+  if (context.mergeMetadata) {
+    const { content, metadata } = parseYamlFrontMatter(fileContent, false);
+    contentToImport = content;
+    if (Object.keys(metadata).length > 0) {
+      context.importedMetadataList.push({
+        metadata,
+        source: normalizedPath
+      });
+      context.accumulatedMetadata = {
+        ...context.accumulatedMetadata,
+        ...metadata
+      };
+      if (!context.importedFiles.includes(normalizedPath)) {
+        context.importedFiles.push(normalizedPath);
+      }
+      if (context.debug) {
+        console.log(
+          `[remarkImports] Collected metadata from ${directive.filePath}:`,
+          Object.keys(metadata)
+        );
       }
     }
   }
-  const loopValue = resolveLoopVariable(variable, metadata, parentContext);
-  fieldTracker.trackField(variable, {
-    value: loopValue,
-    hasLogic: true,
-    mixinUsed: "loop"
-  });
-  if (Array.isArray(loopValue)) {
-    return expandArrayLoop(
-      variable,
-      content,
-      loopValue,
-      metadata,
-      parentContext,
-      enableFieldTracking
-    );
-  } else if (loopValue) {
-    return expandConditionalBlock(
-      variable,
-      content,
-      loopValue,
-      metadata,
-      parentContext,
-      enableFieldTracking
-    );
-  } else {
-    return "";
+  if (directive.section) {
+    contentToImport = extractSection(contentToImport, directive.section, context.debug);
+  }
+  const nestedContext = {
+    ...context,
+    depth: context.depth + 1,
+    importStack: [...context.importStack, normalizedPath],
+    basePath: pathBrowserifyExports.dirname(normalizedPath)
+    // Update base path for relative imports
+  };
+  const processedContent = await processNestedImportsToAST(contentToImport, nestedContext);
+  if (context.mergeMetadata && Object.keys(context.accumulatedMetadata).length > 0) {
+    return await expandMixinsInAST(processedContent, context.accumulatedMetadata);
   }
+  return processedContent;
 }
-function expandArrayLoop(variable, content, items, metadata, parentContext, enableFieldTracking = true) {
-  const expandedParts = [];
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    const loopContext = {
-      variable,
-      item,
-      index: i,
-      total: items.length,
-      parent: parentContext
+function performSequentialMerge(context) {
+  if (context.importedMetadataList.length === 0) {
+    return {
+      metadata: {},
+      stats: void 0
     };
-    const enhancedMetadata = createEnhancedMetadata(metadata, item, loopContext);
-    let processedContent = content;
-    processedContent = processTemplateLoops(
-      processedContent,
-      enhancedMetadata,
-      loopContext,
-      enableFieldTracking
+  }
+  if (Date.now() - context.startTime > context.timeoutMs) {
+    throw new Error(
+      `Import processing timed out after ${context.timeoutMs}ms. This may indicate complex nested imports or slow file operations.`
     );
-    processedContent = processItemMixins(
-      processedContent,
-      enhancedMetadata,
-      loopContext,
-      enableFieldTracking
-    );
-    processedContent = convertMarkdownListToHtml(processedContent);
-    expandedParts.push(processedContent);
   }
-  return expandedParts.join("\n");
-}
-function expandConditionalBlock(variable, content, value, metadata, parentContext, enableFieldTracking = true) {
-  const enhancedMetadata = {
-    ...metadata,
-    [variable]: value
+  const mergeOptions = {
+    filterReserved: context.filterReserved,
+    validateTypes: context.validateTypes,
+    logOperations: context.logImportOperations,
+    includeStats: true,
+    timeoutMs: Math.max(1e3, context.timeoutMs - (Date.now() - context.startTime))
   };
-  let processedContent = processTemplateLoops(
-    content,
-    enhancedMetadata,
-    parentContext,
-    enableFieldTracking
-  );
-  processedContent = processItemMixins(
-    processedContent,
-    enhancedMetadata,
-    parentContext,
-    enableFieldTracking
-  );
-  return processedContent;
-}
-function resolveLoopVariable(variable, metadata, parentContext) {
-  const resolvedFromMetadata = resolvePath(metadata, variable);
-  if (resolvedFromMetadata !== void 0) {
-    return resolvedFromMetadata;
+  const metadataList = context.importedMetadataList.map((item) => item.metadata);
+  if (context.debug) {
+    console.log(
+      `[remarkImports] Performing sequential merge of ${metadataList.length} metadata objects`
+    );
   }
-  if (parentContext && parentContext.item) {
-    const resolvedFromContext = resolvePath(parentContext.item, variable);
-    if (resolvedFromContext !== void 0) {
-      return resolvedFromContext;
+  try {
+    const result = mergeSequentially({}, metadataList, mergeOptions);
+    if (context.onMetadataMerged && Object.keys(result.metadata).length > 0) {
+      context.onMetadataMerged(result.metadata, "merged-imports");
     }
-  }
-  let ctx = parentContext;
-  while (ctx && ctx.parent) {
-    ctx = ctx.parent;
-    if (ctx.item) {
-      const resolvedFromNestedContext = resolvePath(ctx.item, variable);
-      if (resolvedFromNestedContext !== void 0) {
-        return resolvedFromNestedContext;
-      }
+    return result;
+  } catch (error) {
+    if (context.debug) {
+      console.warn("[remarkImports] Sequential merge failed:", error);
     }
+    throw error;
   }
-  return void 0;
 }
-function createEnhancedMetadata(metadata, item, context) {
-  const enhanced = { ...metadata };
-  if (item && typeof item === "object" && !Array.isArray(item)) {
-    Object.assign(enhanced, item);
+function loadFileContent(filePath, context) {
+  if (context.contentCache.has(filePath)) {
+    return context.contentCache.get(filePath);
   }
-  enhanced["."] = item;
-  enhanced["@index"] = context.index;
-  enhanced["@total"] = context.total;
-  enhanced["@first"] = context.index === 0;
-  enhanced["@last"] = context.index === context.total - 1;
-  return enhanced;
-}
-function evaluateHelperExpression(expression, metadata) {
   try {
-    const match = expression.match(/^(\w+)\((.*)\)$/);
-    if (!match) return void 0;
-    const [, helperName, argsString] = match;
-    const helper = extensionHelpers[helperName];
-    if (!helper || typeof helper !== "function") {
-      return void 0;
-    }
-    const args = argsString ? parseHelperArguments(argsString, metadata) : [];
-    return helper(...args);
+    if (existsSync(filePath)) ;
   } catch (error) {
-    console.error(`Error evaluating helper expression: ${expression}`, error);
-    return void 0;
-  }
-}
-function parseHelperArguments(argsString, metadata) {
-  const args = [];
-  let currentArg = "";
-  let parenDepth = 0;
-  let inQuotes = false;
-  let quoteChar = "";
-  for (let i = 0; i < argsString.length; i++) {
-    const char = argsString[i];
-    if ((char === '"' || char === "'") && !inQuotes) {
-      inQuotes = true;
-      quoteChar = char;
-      currentArg += char;
-    } else if (char === quoteChar && inQuotes) {
-      inQuotes = false;
-      quoteChar = "";
-      currentArg += char;
-    } else if (char === "(" && !inQuotes) {
-      parenDepth++;
-      currentArg += char;
-    } else if (char === ")" && !inQuotes) {
-      parenDepth--;
-      currentArg += char;
-    } else if (char === "," && parenDepth === 0 && !inQuotes) {
-      args.push(resolveHelperArgument(currentArg.trim(), metadata));
-      currentArg = "";
-    } else {
-      currentArg += char;
+    if (context.debug) {
+      console.warn(`[remarkImports] Failed to load import file "${filePath}":`, error);
     }
   }
-  if (currentArg.trim()) {
-    args.push(resolveHelperArgument(currentArg.trim(), metadata));
-  }
-  return args;
+  return null;
 }
-function resolveHelperArgument(arg, metadata) {
-  if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
-    return arg.slice(1, -1);
-  }
-  if (arg === "true") return true;
-  if (arg === "false") return false;
-  if (/^\d+$/.test(arg)) {
-    return parseInt(arg, 10);
-  }
-  if (/^\d+\.\d+$/.test(arg)) {
-    return parseFloat(arg);
+function extractSection(content, sectionName, debug) {
+  const lines = content.split("\n");
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+  let sectionLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      const [, hashes, title] = headerMatch;
+      const level = hashes.length;
+      if (title.toLowerCase() === sectionName.toLowerCase()) {
+        sectionStart = i + 1;
+        sectionLevel = level;
+        if (debug) {
+          console.log(`[remarkImports] Found section '${sectionName}' at line ${i}`);
+        }
+        break;
+      }
+    }
   }
-  if (arg === "@today") {
-    return metadata["@today"] ? new Date(metadata["@today"]) : /* @__PURE__ */ new Date();
+  if (sectionStart === -1) {
+    if (debug) {
+      console.warn(`[remarkImports] Section '${sectionName}' not found`);
+    }
+    return content;
   }
-  if (arg.includes("(") && arg.includes(")")) {
-    const result = evaluateHelperExpression(arg, metadata);
-    if (result !== void 0) {
-      return result;
+  for (let i = sectionStart; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      const [, hashes] = headerMatch;
+      const level = hashes.length;
+      if (level <= sectionLevel) {
+        sectionEnd = i;
+        break;
+      }
     }
   }
-  return resolvePath(metadata, arg);
+  return lines.slice(sectionStart, sectionEnd).join("\n").trim();
 }
-function resolvePath(obj, path) {
-  const keys = path.split(".");
-  let current = obj;
-  for (const key of keys) {
-    if (current && typeof current === "object" && key in current) {
-      current = current[key];
+async function processNestedImportsToAST(content, context) {
+  const nodes = await parseImportedContentToAST(content);
+  const hasImports = nodes.some((node) => {
+    if (node.type === "paragraph") {
+      return node.children.some(
+        (child) => child.type === "text" && extractImportDirectives(child.value).length > 0
+      );
+    }
+    return false;
+  });
+  if (!hasImports) {
+    return nodes;
+  }
+  const processedNodes = [];
+  for (const node of nodes) {
+    if (node.type === "paragraph") {
+      const paragraph = node;
+      const hasDirectives = paragraph.children.some(
+        (child) => child.type === "text" && extractImportDirectives(child.value).length > 0
+      );
+      if (hasDirectives) {
+        const importedNodes = await processParagraphWithImports(paragraph, context);
+        processedNodes.push(...importedNodes);
+      } else {
+        processedNodes.push(node);
+      }
     } else {
-      return void 0;
+      processedNodes.push(node);
     }
   }
-  return current;
+  return processedNodes;
 }
-function processItemMixins(content, metadata, context, enableFieldTracking = true) {
-  const mixinPattern = /\{\{([^}]+)\}\}/g;
-  return content.replace(mixinPattern, (match, variable) => {
-    const trimmedVar = variable.trim();
-    if (trimmedVar.includes("?") && trimmedVar.includes(":")) {
-      const result = processConditionalExpression(trimmedVar, metadata, enableFieldTracking);
-      if (enableFieldTracking) {
-        return `<span class="highlight">${result}</span>`;
-      }
-      return result;
-    }
-    if (trimmedVar.includes("(") && trimmedVar.includes(")")) {
-      const result = evaluateHelperExpression(trimmedVar, metadata);
-      if (result !== void 0) {
-        fieldTracker.trackField(trimmedVar, {
-          value: result,
-          hasLogic: true,
-          mixinUsed: "helper"
-        });
-        if (enableFieldTracking) {
-          const escapedField = escapeHtmlAttribute$1(trimmedVar);
-          const stringResult = String(result);
-          return `<span class="highlight"><span class="imported-value" data-field="${escapedField}">${stringResult}</span></span>`;
+async function expandMixinsInAST(nodes, metadata) {
+  const processedNodes = [];
+  for (const node of nodes) {
+    if (node.type === "paragraph") {
+      const paragraph = node;
+      const processedChildren = [];
+      for (const child of paragraph.children) {
+        if (child.type === "text") {
+          processedChildren.push(child);
+        } else {
+          processedChildren.push(child);
         }
-        return String(result);
-      }
-    }
-    const value = resolveVariablePath(trimmedVar, metadata);
-    if (value === void 0 || value === null) {
-      if (enableFieldTracking) {
-        return `<span class="legal-field missing-value" data-field="${escapeHtmlAttribute$1(trimmedVar)}">[[${trimmedVar}]]</span>`;
       }
-      return `{{${trimmedVar}}}`;
-    }
-    if (enableFieldTracking) {
-      return `<span class="imported-value" data-field="${escapeHtmlAttribute$1(trimmedVar)}">${String(value)}</span>`;
-    }
-    return String(value);
-  });
-}
-function processConditionalExpression(expression, metadata, enableFieldTracking = true) {
-  const questionIndex = findOperatorIndex(expression, "?");
-  const colonIndex = findOperatorIndex(expression, ":", questionIndex);
-  if (questionIndex === -1 || colonIndex === -1) {
-    return expression;
-  }
-  const condition = expression.substring(0, questionIndex).trim();
-  const truePart = expression.substring(questionIndex + 1, colonIndex).trim();
-  const falsePart = expression.substring(colonIndex + 1).trim();
-  const conditionValue = resolveVariablePath(condition, metadata);
-  const selectedPart = conditionValue ? truePart : falsePart;
-  if (selectedPart.startsWith('"') && selectedPart.endsWith('"') || // eslint-disable-next-line quotes
-  selectedPart.startsWith("'") && selectedPart.endsWith("'")) {
-    const unquotedValue = selectedPart.slice(1, -1);
-    if (enableFieldTracking) {
-      return `<span class="imported-value" data-field="${escapeHtmlAttribute$1(expression)}">${unquotedValue}</span>`;
+      processedNodes.push({
+        ...paragraph,
+        children: processedChildren
+      });
+    } else {
+      processedNodes.push(node);
     }
-    return unquotedValue;
   }
-  const processedValue = processExpression(selectedPart, metadata);
-  if (enableFieldTracking) {
-    return `<span class="imported-value" data-field="${escapeHtmlAttribute$1(expression)}">${processedValue}</span>`;
-  }
-  return processedValue;
+  return processedNodes;
 }
-function findOperatorIndex(expression, operator, startIndex = 0) {
-  let inQuotes = false;
-  let quoteChar = "";
-  for (let i = startIndex; i < expression.length; i++) {
-    const char = expression[i];
-    if (!inQuotes && (char === '"' || char === "'")) {
-      inQuotes = true;
-      quoteChar = char;
-    } else if (inQuotes && char === quoteChar) {
-      inQuotes = false;
-      quoteChar = "";
-    } else if (!inQuotes && char === operator) {
-      return i;
-    }
-  }
-  return -1;
-}
-function processExpression(expression, metadata) {
-  if (expression.includes("+") && (expression.includes('"') || expression.includes("'"))) {
-    return evaluateStringConcatenation(expression, metadata);
-  }
-  if (expression.includes("*") || expression.includes("/") || expression.includes("+") || expression.includes("-")) {
-    return evaluateMathematicalExpression(expression, metadata);
-  }
-  const value = resolveVariablePath(expression, metadata);
-  return value !== void 0 ? String(value) : expression;
-}
-function evaluateStringConcatenation(expression, metadata) {
-  try {
-    let processedExpression = expression.trim();
-    const variablePattern = /\b[a-zA-Z_][a-zA-Z0-9_.]*\b/g;
-    const variables = /* @__PURE__ */ new Set();
-    let match;
-    let inQuotes = false;
-    let quoteChar = "";
-    for (let i = 0; i < expression.length; i++) {
-      const char = expression[i];
-      if (!inQuotes && (char === '"' || char === "'")) {
-        inQuotes = true;
-        quoteChar = char;
-      } else if (inQuotes && char === quoteChar) {
-        inQuotes = false;
-        quoteChar = "";
-      }
-    }
-    while ((match = variablePattern.exec(expression)) !== null) {
-      const beforeMatch = expression.substring(0, match.index);
-      const openQuotes = (beforeMatch.match(/"/g) || []).length;
-      const openSingleQuotes = (beforeMatch.match(/'/g) || []).length;
-      if (openQuotes % 2 === 0 && openSingleQuotes % 2 === 0) {
-        variables.add(match[0]);
-      }
-    }
-    for (const variable of variables) {
-      const value = resolveVariablePath(variable, metadata);
-      if (value !== void 0) {
-        const regex = new RegExp(`\\b${variable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
-        if (typeof value === "string") {
-          processedExpression = processedExpression.replace(regex, `"${value}"`);
-        } else {
-          processedExpression = processedExpression.replace(regex, String(value));
-        }
-      } else {
-        return expression;
-      }
-    }
-    const result = new Function(`"use strict"; return (${processedExpression})`)();
-    return String(result);
-  } catch (error) {
-    return expression;
-  }
+
+const LEGAL_HEADER_PATTERN = /^(l{1,9})\.\s+(.+)$/;
+function getHeadingLevel(pattern) {
+  return pattern.length;
 }
-function evaluateMathematicalExpression(expression, metadata) {
-  try {
-    let processedExpression = expression;
-    const variablePattern = /[a-zA-Z_][a-zA-Z0-9_.]*(?![a-zA-Z0-9_.])/g;
-    const variables = /* @__PURE__ */ new Set();
-    let match;
-    while ((match = variablePattern.exec(expression)) !== null) {
-      variables.add(match[0]);
-    }
-    for (const variable of variables) {
-      const value = resolveVariablePath(variable, metadata);
-      if (value !== void 0 && !isNaN(Number(value))) {
-        const regex = new RegExp(`\\b${variable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
-        processedExpression = processedExpression.replace(regex, String(value));
-      } else {
-        return expression;
-      }
-    }
-    if (!/^[\d\s+\-*/().]+$/.test(processedExpression)) {
-      return expression;
+function isLegalHeader(node) {
+  if (node.children.length === 1 && node.children[0].type === "text") {
+    const textNode = node.children[0];
+    const match = textNode.value.match(LEGAL_HEADER_PATTERN);
+    if (match) {
+      const [, levelPattern, headerText] = match;
+      return {
+        level: getHeadingLevel(levelPattern),
+        text: headerText.trim()
+      };
     }
-    const result = new Function(`"use strict"; return (${processedExpression})`)();
-    return typeof result === "number" && !isNaN(result) ? String(result) : expression;
-  } catch (error) {
-    return expression;
   }
-}
-function resolveVariablePath(path, metadata, context) {
-  if (path === ".") {
-    return metadata["."];
-  }
-  const parts = path.split(".");
-  let current = metadata;
-  for (const part of parts) {
-    if (current && typeof current === "object" && Object.prototype.hasOwnProperty.call(current, part)) {
-      current = current[part];
-    } else {
-      return void 0;
+  if (node.children.length > 0 && node.children[0].type === "text") {
+    const firstChild = node.children[0];
+    const match = firstChild.value.match(/^(l{1,5})\.\s*/);
+    if (match) {
+      const [fullMatch, levelPattern] = match;
+      const remainingText = firstChild.value.slice(fullMatch.length);
+      const otherText = node.children.slice(1).map((child) => {
+        if (child.type === "text") return child.value;
+        if (child.type === "html") return child.value || "";
+        return "";
+      }).join("");
+      return {
+        level: getHeadingLevel(levelPattern),
+        text: (remainingText + otherText).trim()
+      };
     }
   }
-  return current;
-}
-function convertMarkdownListToHtml(content) {
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("- ")) {
-    const listItemContent = trimmedContent.substring(2).trim();
-    return `<li>${listItemContent}</li>`;
-  }
-  return content;
-}
-function evaluateCondition(condition, metadata) {
-  const value = resolveVariablePath(condition, metadata);
-  if (value === null || value === void 0) return false;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return value !== 0;
-  if (typeof value === "string") return value.length > 0;
-  if (Array.isArray(value)) return value.length > 0;
-  if (typeof value === "object") return Object.keys(value).length > 0;
-  return Boolean(value);
-}
-function processTemplateContent(content, metadata, context, enableFieldTracking = true) {
-  let processedContent = processTemplateLoops(content, metadata, context, enableFieldTracking);
-  processedContent = processedContent.replace(/\{\{([^#/][^}]*)\}\}/g, (match, variable) => {
-    const trimmedVar = variable.trim();
-    const value = resolveVariablePath(trimmedVar, metadata);
-    if (value !== void 0) {
-      if (enableFieldTracking) {
-        const isEmptyValue = value === null || value === "" || typeof value === "string" && value.trim() === "";
-        const cssClass = isEmptyValue ? "legal-field missing-value" : "legal-field imported-value";
-        fieldTracker.trackField(trimmedVar, {
-          value,
-          originalValue: match,
-          hasLogic: false
-        });
-        return `<span class="${cssClass}" data-field="${escapeHtmlAttribute$1(trimmedVar)}">${String(value)}</span>`;
-      }
-      return String(value);
-    }
-    return match;
-  });
-  return processedContent;
-}
-
-function escapeHtmlAttribute(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return null;
 }
-function processMixins(content, metadata, options = {}) {
-  if (options.noMixins) {
-    return content;
-  }
-  const mixinPattern = /\{\{([^}]+)\}\}/g;
-  function resolvePath(obj, path) {
-    if (path === ".") {
-      return obj?.["."];
-    }
-    return path.split(".").reduce((current, part) => {
-      const match = part.match(/^(\w+)\[(\d+)\]$/);
+function convertToHeading(node, level, text) {
+  const heading = {
+    type: "heading",
+    depth: level,
+    children: parseMarkdownInlineFormatting(text)
+  };
+  heading.data = {
+    isLegalHeader: true,
+    hProperties: {}
+    // Initialize for remarkHeaders to add CSS classes
+  };
+  if (node.children.length > 1 || node.children[0].type === "text" && node.children[0].value.includes("<span")) {
+    const firstChild = node.children[0];
+    if (firstChild.type === "text") {
+      const match = firstChild.value.match(/^(l{1,5})\.\s*/);
       if (match) {
-        const [, key, index] = match;
-        return current?.[key]?.[parseInt(index, 10)];
-      }
-      return current?.[part];
-    }, obj);
-  }
-  function evaluateHelperExpression(expression, metadata2) {
-    try {
-      const match = expression.match(/^(\w+)\((.*)\)$/);
-      if (!match) return void 0;
-      const [, helperName, argsString] = match;
-      const helper = extensionHelpers[helperName];
-      if (!helper || typeof helper !== "function") {
-        return void 0;
-      }
-      const args = parseArguments(argsString, metadata2);
-      return helper(...args);
-    } catch (error) {
-      console.warn(`Error evaluating helper expression: ${expression}`, error);
-      return void 0;
-    }
-  }
-  function parseArguments(argsString, metadata2) {
-    if (!argsString.trim()) return [];
-    const args = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = "";
-    let parenDepth = 0;
-    for (let i = 0; i < argsString.length; i++) {
-      const char = argsString[i];
-      if (!inQuotes && (char === '"' || char === "'")) {
-        inQuotes = true;
-        quoteChar = char;
-        current += char;
-        continue;
-      }
-      if (inQuotes && char === quoteChar) {
-        inQuotes = false;
-        quoteChar = "";
-        current += char;
-        continue;
-      }
-      if (!inQuotes && char === "(") {
-        parenDepth++;
-        current += char;
-        continue;
-      }
-      if (!inQuotes && char === ")") {
-        parenDepth--;
-        current += char;
-        continue;
-      }
-      if (!inQuotes && char === "," && parenDepth === 0) {
-        args.push(parseArgument(current.trim(), metadata2));
-        current = "";
-        continue;
-      }
-      current += char;
-    }
-    if (current.trim()) {
-      args.push(parseArgument(current.trim(), metadata2));
-    }
-    return args;
-  }
-  function parseArgument(arg, metadata2) {
-    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
-      return arg.slice(1, -1);
-    }
-    if (/^-?\d+(\.\d+)?$/.test(arg)) {
-      return parseFloat(arg);
-    }
-    if (arg === "true") return true;
-    if (arg === "false") return false;
-    if (arg === "null") return null;
-    if (arg === "undefined") return void 0;
-    if (arg === "@today") {
-      return metadata2["@today"] ? new Date(metadata2["@today"]) : /* @__PURE__ */ new Date();
-    }
-    if (arg.includes("(") && arg.includes(")")) {
-      const result = evaluateHelperExpression(arg, metadata2);
-      if (result !== void 0) {
-        return result;
-      }
-    }
-    return resolvePath(metadata2, arg);
-  }
-  function evaluateExpression(expression, metadata2) {
-    try {
-      let cleanExpression = expression.trim();
-      const variables = Object.keys(metadata2);
-      variables.forEach((varName) => {
-        const value = metadata2[varName];
-        const regex = new RegExp(`\\b${varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
-        if (typeof value === "string") {
-          cleanExpression = cleanExpression.replace(regex, `"${value}"`);
-        } else if (typeof value === "number") {
-          cleanExpression = cleanExpression.replace(regex, String(value));
-        } else if (value === null || value === void 0) {
-          cleanExpression = cleanExpression.replace(regex, "null");
-        } else {
-          cleanExpression = cleanExpression.replace(regex, JSON.stringify(value));
-        }
-      });
-      if (cleanExpression.includes("+") && cleanExpression.includes('"')) {
-        const result = Function(`"use strict"; return (${cleanExpression})`)();
-        return String(result);
-      } else if (/^[\d\s+\-*/().]+$/.test(cleanExpression)) {
-        const result = Function(`"use strict"; return (${cleanExpression})`)();
-        return String(result);
+        const [fullMatch] = match;
+        firstChild.value = firstChild.value.slice(fullMatch.length);
+        heading.children = node.children.filter((child) => {
+          if (child.type === "text" && child.value.trim() === "") {
+            return false;
+          }
+          return true;
+        });
       }
-      return expression;
-    } catch (error) {
-      return expression;
     }
   }
-  function replaceMixins(text, depth = 0) {
-    if (depth > 10) {
-      return text;
-    }
-    return text.replace(mixinPattern, (match, variable) => {
-      return processVariable(match, variable, depth);
-    });
-  }
-  function processVariable(match, variable, depth) {
-    const trimmedVar = variable.trim();
-    if (trimmedVar.includes("(") && trimmedVar.includes(")")) {
-      const result = evaluateHelperExpression(trimmedVar, metadata);
-      if (result !== void 0) {
-        fieldTracker.trackField(trimmedVar, {
-          value: result,
-          hasLogic: true,
-          mixinUsed: "helper"
-        });
-        if (options.enableFieldTrackingInMarkdown) {
-          return `<span class="highlight"><span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${String(result)}</span></span>`;
-        }
-        return String(result);
-      }
-      if (options.enableFieldTrackingInMarkdown) {
-        return `<span class="legal-field highlight"><span class="legal-field missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span></span>`;
-      }
-      return `{{${trimmedVar}}}`;
+  return heading;
+}
+const remarkLegalHeadersParser = (options = {}) => {
+  const { debug = false } = options;
+  return (tree) => {
+    if (debug) {
+      console.log("🔍 [remarkLegalHeadersParser] Parsing legal header syntax");
     }
-    if (trimmedVar.includes("?")) {
-      const questionIndex = trimmedVar.indexOf("?");
-      const colonIndex = trimmedVar.indexOf(":", questionIndex);
-      if (colonIndex !== -1) {
-        const condition = trimmedVar.substring(0, questionIndex).trim();
-        const truePart = trimmedVar.substring(questionIndex + 1, colonIndex).trim();
-        const falsePart = trimmedVar.substring(colonIndex + 1).trim();
-        const conditionValue = resolvePath(metadata, condition);
-        const selectedPart = conditionValue ? truePart : falsePart;
-        fieldTracker.trackField(condition, {
-          value: conditionValue,
-          hasLogic: true,
-          mixinUsed: "conditional"
-        });
-        if (selectedPart) {
-          let processedPart;
-          if (selectedPart.includes("+") || selectedPart.includes("*") || selectedPart.includes("-") || selectedPart.includes("/")) {
-            processedPart = evaluateExpression(selectedPart, metadata);
-            if (processedPart === selectedPart) {
-              processedPart = replaceMixins(selectedPart, depth + 1);
+    let convertedCount = 0;
+    const nodesToReplace = [];
+    visit(tree, "paragraph", (node, index, parent) => {
+      if (parent && typeof index === "number") {
+        if (node.children.length === 1 && node.children[0].type === "text") {
+          const textNode = node.children[0];
+          const lines = textNode.value.split("\n");
+          const hasLegalHeaders = lines.some((line) => LEGAL_HEADER_PATTERN.test(line));
+          if (hasLegalHeaders) {
+            const newNodes = [];
+            const nonHeaderLines = [];
+            for (const line of lines) {
+              const match = line.match(LEGAL_HEADER_PATTERN);
+              if (match) {
+                if (nonHeaderLines.length > 0) {
+                  newNodes.push({
+                    type: "paragraph",
+                    children: [
+                      {
+                        type: "text",
+                        value: nonHeaderLines.join("\n")
+                      }
+                    ]
+                  });
+                  nonHeaderLines.length = 0;
+                }
+                const [, levelPattern, headerText] = match;
+                const level = getHeadingLevel(levelPattern);
+                if (debug) {
+                  console.log(
+                    `🔄 [remarkLegalHeadersParser] Converting "${line.substring(0, 50)}..." to level ${level} heading`
+                  );
+                }
+                const headingNode = {
+                  type: "heading",
+                  depth: level,
+                  children: parseMarkdownInlineFormatting(headerText.trim())
+                };
+                headingNode.data = { isLegalHeader: true };
+                newNodes.push(headingNode);
+                convertedCount++;
+              } else {
+                nonHeaderLines.push(line);
+              }
             }
-          } else {
-            processedPart = replaceMixins(selectedPart, depth + 1);
+            if (nonHeaderLines.length > 0) {
+              newNodes.push({
+                type: "paragraph",
+                children: [
+                  {
+                    type: "text",
+                    value: nonHeaderLines.join("\n")
+                  }
+                ]
+              });
+            }
+            if (newNodes.length > 0) {
+              nodesToReplace.push({ parent, index, newNodes });
+            }
+          }
+        } else if (node.children.length > 1) {
+          let fullText = "";
+          const childrenMap = /* @__PURE__ */ new Map();
+          for (let i = 0; i < node.children.length; i++) {
+            const child = node.children[i];
+            const start = fullText.length;
+            if (child.type === "text") {
+              fullText += child.value;
+            } else if (child.type === "emphasis") {
+              const emphasisText = child.children.map((c) => c.value || "").join("");
+              fullText += `_${emphasisText}_`;
+            } else if (child.type === "strong") {
+              const strongText = child.children.map((c) => c.value || "").join("");
+              fullText += `__${strongText}__`;
+            } else if (child.type === "link") {
+              const linkText = child.children.map((c) => c.value || "").join("");
+              const url = child.url || "";
+              fullText += `[${linkText}](${url})`;
+            } else if (child.type === "inlineCode") {
+              fullText += `\`${child.value || ""}\``;
+            } else {
+              fullText += child.value || "";
+            }
+            const end = fullText.length;
+            childrenMap.set(i, { start, end, child });
           }
-          if (options.enableFieldTrackingInMarkdown) {
-            return `<span class="highlight"><span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${processedPart}</span></span>`;
+          const lines = fullText.split("\n");
+          const hasLegalHeaders = lines.some((line) => LEGAL_HEADER_PATTERN.test(line));
+          if (hasLegalHeaders) {
+            const newNodes = [];
+            const nonHeaderLines = [];
+            for (const line of lines) {
+              const match = line.match(LEGAL_HEADER_PATTERN);
+              if (match) {
+                if (nonHeaderLines.length > 0) {
+                  newNodes.push({
+                    type: "paragraph",
+                    children: [
+                      {
+                        type: "text",
+                        value: nonHeaderLines.join("\n")
+                      }
+                    ]
+                  });
+                  nonHeaderLines.length = 0;
+                }
+                const [, levelPattern, headerText] = match;
+                const level = getHeadingLevel(levelPattern);
+                if (debug) {
+                  console.log(
+                    `🔄 [remarkLegalHeadersParser] Converting complex "${line.substring(0, 50)}..." to level ${level} heading`
+                  );
+                }
+                const headingNode = {
+                  type: "heading",
+                  depth: level,
+                  children: parseMarkdownInlineFormatting(headerText.trim())
+                };
+                headingNode.data = { isLegalHeader: true };
+                newNodes.push(headingNode);
+                convertedCount++;
+              } else {
+                nonHeaderLines.push(line);
+              }
+            }
+            if (nonHeaderLines.length > 0) {
+              newNodes.push({
+                type: "paragraph",
+                children: [
+                  {
+                    type: "text",
+                    value: nonHeaderLines.join("\n")
+                  }
+                ]
+              });
+            }
+            if (newNodes.length > 0) {
+              nodesToReplace.push({ parent, index, newNodes });
+            }
           }
-          return processedPart;
+        }
+      } else {
+        if (debug) {
+          const firstChildText = node.children[0]?.type === "text" ? node.children[0].value : "<non-text>";
+          console.log(`🔍 [remarkLegalHeadersParser] Single-line paragraph: "${firstChildText}"`);
+        }
+        const headerInfo = isLegalHeader(node);
+        if (headerInfo && parent && typeof index === "number") {
+          if (debug) {
+            const firstChildText = node.children[0].type === "text" ? node.children[0].value : "";
+            console.log(
+              `🔄 [remarkLegalHeadersParser] Converting "${firstChildText.substring(0, 50)}..." to level ${headerInfo.level} heading`
+            );
+          }
+          const heading = convertToHeading(node, headerInfo.level, headerInfo.text);
+          nodesToReplace.push({ parent, index, newNodes: [heading] });
+          convertedCount++;
         }
       }
-      if (options.enableFieldTrackingInMarkdown) {
-        return `<span class="legal-field highlight"><span class="legal-field missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span></span>`;
-      }
-      return `{{${trimmedVar}}}`;
-    }
-    const value = resolvePath(metadata, trimmedVar);
-    if (value === void 0 || value === null) {
-      fieldTracker.trackField(trimmedVar, {
-        value: void 0,
-        hasLogic: false
-      });
-      if (options.enableFieldTrackingInMarkdown) {
-        return `<span class="legal-field missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span>`;
-      }
-      return `{{${trimmedVar}}}`;
-    }
-    fieldTracker.trackField(trimmedVar, {
-      value,
-      hasLogic: false
     });
-    const stringValue = String(value);
-    if (mixinPattern.test(stringValue)) {
-      const nestedResult = replaceMixins(stringValue, depth + 1);
-      if (options.enableFieldTrackingInMarkdown) {
-        return `<span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${nestedResult}</span>`;
-      }
-      return nestedResult;
-    }
-    if (options.enableFieldTrackingInMarkdown) {
-      return `<span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${stringValue}</span>`;
+    for (let i = nodesToReplace.length - 1; i >= 0; i--) {
+      const { parent, index, newNodes } = nodesToReplace[i];
+      parent.children.splice(index, 1, ...newNodes);
     }
-    return stringValue;
-  }
-  const loopProcessedContent = processTemplateLoops(
-    content,
-    metadata,
-    void 0,
-    options.enableFieldTrackingInMarkdown || false
-  );
-  return replaceMixins(loopProcessedContent);
-}
-
-const MAX_HEADER_LEVEL = 9;
-const FUNCTION_CALL_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*\s*\(/;
-const CONDITIONAL_PATTERN = /\?.*:/;
-const remarkImports = (options) => {
-  const {
-    basePath = ".",
-    mergeMetadata = true,
-    debug = false,
-    maxDepth = 10,
-    timeoutMs = 3e4,
-    filterReserved = true,
-    validateTypes = true,
-    logImportOperations = false,
-    onMetadataMerged,
-    importStack = []
-  } = options;
-  return (tree) => {
-    const startTime = Date.now();
     if (debug) {
-      console.log("[remarkImports] Processing imports with options:", {
-        basePath,
-        mergeMetadata,
-        maxDepth,
-        timeoutMs,
-        filterReserved,
-        validateTypes,
-        currentDepth: importStack.length
-      });
-    }
-    const context = {
-      depth: importStack.length,
-      maxDepth,
-      basePath,
-      mergeMetadata,
-      debug,
-      startTime,
-      timeoutMs,
-      filterReserved,
-      validateTypes,
-      logImportOperations,
-      onMetadataMerged,
-      importStack: [...importStack],
-      contentCache: /* @__PURE__ */ new Map(),
-      importedMetadataList: [],
-      importedFiles: [],
-      accumulatedMetadata: {}
-      // Initialize with empty metadata
-    };
-    visit(tree, (node) => {
-      if (node.type === "text") {
-        processTextNode(node, context);
-      } else if (node.type === "paragraph") {
-        processParagraphNode(node, context);
-      }
-    });
-    if (context.mergeMetadata && context.importedMetadataList.length > 0) {
-      const mergedResult = performSequentialMerge(context);
-      tree._importedMetadata = mergedResult.metadata;
-      tree._importStats = mergedResult.stats;
+      console.log(`✅ [remarkLegalHeadersParser] Converted ${convertedCount} legal headers`);
     }
   };
 };
-function processTextNode(node, context) {
-  const originalText = node.value;
-  const importDirectives = extractImportDirectives(originalText);
-  if (importDirectives.length === 0) {
-    return;
-  }
-  if (context.debug) {
-    console.log(`[remarkImports] Found ${importDirectives.length} import directives in text node`);
-  }
-  let processedText = originalText;
-  for (let i = importDirectives.length - 1; i >= 0; i--) {
-    const directive = importDirectives[i];
-    const result = processImportDirective(directive, context);
-    processedText = processedText.substring(0, directive.start) + result + processedText.substring(directive.end);
-  }
-  node.value = processedText;
-}
-function processParagraphNode(node, context) {
-  node.children.forEach((child) => {
-    if (child.type === "text") {
-      processTextNode(child, context);
-    }
-  });
-}
-function extractImportDirectives(text) {
-  const directives = [];
-  const importRegex = /@import\s+([^\s#]+)(?:#([^\s]+))?/g;
-  let match;
-  while ((match = importRegex.exec(text)) !== null) {
-    const [fullMatch, filePath, section] = match;
-    directives.push({
-      filePath: filePath.trim(),
-      section: section?.trim(),
-      start: match.index,
-      end: match.index + fullMatch.length,
-      fullMatch
-    });
-  }
-  return directives;
-}
-function processImportDirective(directive, context) {
-  if (context.depth >= context.maxDepth) {
-    console.warn(
-      `[remarkImports] Maximum import depth (${context.maxDepth}) reached for file "${directive.filePath}"`
-    );
-    return directive.fullMatch;
-  }
-  const absolutePath = pathBrowserifyExports.resolve(context.basePath, directive.filePath);
-  const normalizedPath = pathBrowserifyExports.normalize(absolutePath);
-  if (context.importStack.includes(normalizedPath)) {
-    console.warn(`[remarkImports] Circular import detected: ${normalizedPath}`);
-    return directive.fullMatch;
+function parseMarkdownInlineFormatting(text) {
+  const children = [];
+  const patterns = [
+    { regex: /\[([^\]]+)\]\([^)]+\)/g, type: "link" },
+    // [text](url) - extract just the text
+    { regex: /`([^`]+)`/g, type: "inlineCode" },
+    // `code`
+    { regex: /\*\*(.+?)\*\*/g, type: "strong" },
+    // **bold**
+    { regex: /__(.+?)__/g, type: "strong" },
+    // __bold__
+    { regex: /\*(.+?)\*/g, type: "emphasis" },
+    // *italic*
+    { regex: /_(.+?)_/g, type: "emphasis" }
+    // _italic_
+  ];
+  const allMatches = [];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.regex.exec(text)) !== null) {
+      allMatches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        type: pattern.type,
+        content: match[1]
+      });
+    }
   }
-  if (context.debug) {
-    console.log(
-      `[remarkImports] Processing import "${directive.filePath}" (resolved: ${normalizedPath})`
-    );
+  allMatches.sort((a, b) => a.start - b.start);
+  const validMatches = [];
+  let lastEnd = 0;
+  for (const match of allMatches) {
+    if (match.start >= lastEnd) {
+      validMatches.push(match);
+      lastEnd = match.end;
+    }
   }
-  const fileContent = loadFileContent(normalizedPath, context);
-  if (!fileContent) {
-    console.warn(`[remarkImports] Import file not found: ${directive.filePath}`);
-    return directive.fullMatch;
+  let pos = 0;
+  for (const match of validMatches) {
+    if (pos < match.start) {
+      const beforeText = text.slice(pos, match.start);
+      if (beforeText) {
+        children.push({
+          type: "text",
+          value: beforeText
+        });
+      }
+    }
+    if (match.type === "inlineCode") {
+      children.push({
+        type: "inlineCode",
+        value: match.content
+      });
+    } else if (match.type === "link") {
+      children.push({
+        type: "text",
+        value: match.content
+      });
+    } else {
+      children.push({
+        type: match.type,
+        children: [
+          {
+            type: "text",
+            value: match.content
+          }
+        ]
+      });
+    }
+    pos = match.end;
   }
-  let contentToImport = fileContent;
-  if (context.mergeMetadata) {
-    const { content, metadata } = parseYamlFrontMatter(fileContent, false);
-    contentToImport = content;
-    if (Object.keys(metadata).length > 0) {
-      context.importedMetadataList.push({
-        metadata,
-        source: normalizedPath
+  if (pos < text.length) {
+    const remainingText = text.slice(pos);
+    if (remainingText) {
+      children.push({
+        type: "text",
+        value: remainingText
       });
-      context.accumulatedMetadata = {
-        ...context.accumulatedMetadata,
-        ...metadata
-      };
-      if (!context.importedFiles.includes(normalizedPath)) {
-        context.importedFiles.push(normalizedPath);
-      }
-      if (context.debug) {
-        console.log(
-          `[remarkImports] Collected metadata from ${directive.filePath}:`,
-          Object.keys(metadata)
-        );
-      }
     }
   }
-  if (directive.section) {
-    contentToImport = extractSection(contentToImport, directive.section, context.debug);
+  if (children.length === 0) {
+    return [
+      {
+        type: "text",
+        value: text
+      }
+    ];
   }
-  const nestedContext = {
-    ...context,
-    depth: context.depth + 1,
-    importStack: [...context.importStack, normalizedPath],
-    basePath: pathBrowserifyExports.dirname(normalizedPath)
-    // Update base path for relative imports
-  };
-  return processNestedImports(contentToImport, nestedContext);
+  return children;
 }
-function performSequentialMerge(context) {
-  if (context.importedMetadataList.length === 0) {
-    return {
-      metadata: {},
-      stats: void 0
-    };
-  }
-  if (Date.now() - context.startTime > context.timeoutMs) {
-    throw new Error(
-      `Import processing timed out after ${context.timeoutMs}ms. This may indicate complex nested imports or slow file operations.`
-    );
-  }
-  const mergeOptions = {
-    filterReserved: context.filterReserved,
-    validateTypes: context.validateTypes,
-    logOperations: context.logImportOperations,
-    includeStats: true,
-    timeoutMs: Math.max(1e3, context.timeoutMs - (Date.now() - context.startTime))
-  };
-  const metadataList = context.importedMetadataList.map((item) => item.metadata);
-  if (context.debug) {
-    console.log(
-      `[remarkImports] Performing sequential merge of ${metadataList.length} metadata objects`
-    );
+
+const EXTENDED_DATE_PATTERN = /@today((?:[+-]\d+[dmy]?(?:\[[^\]]+\])?)|(?:[+-]\d+[dmy]?)|(?:\[[^\]]+\]))?/g;
+function parseDateToken(token) {
+  if (!token) return { arithmetic: null, format: null, isValid: true };
+  if (!/^[+-]?\d*[dmy]?(\[[^\]]+\])?$/.test(token)) {
+    return { arithmetic: null, format: null, isValid: false };
   }
-  try {
-    const result = mergeSequentially({}, metadataList, mergeOptions);
-    if (context.onMetadataMerged && Object.keys(result.metadata).length > 0) {
-      context.onMetadataMerged(result.metadata, "merged-imports");
-    }
-    return result;
-  } catch (error) {
-    if (context.debug) {
-      console.warn("[remarkImports] Sequential merge failed:", error);
+  const formatMatch = token.match(/\[([^\]]+)\]/);
+  const format = formatMatch ? formatMatch[1] : null;
+  const arithmeticPart = token.replace(/\[([^\]]+)\]/, "");
+  let arithmetic = null;
+  if (arithmeticPart) {
+    const arithmeticMatch = arithmeticPart.match(/^([+-])(\d+)([dmy]?)$/);
+    if (arithmeticMatch) {
+      const [, sign, amount, suffix] = arithmeticMatch;
+      const numAmount = parseInt(amount) * (sign === "-" ? -1 : 1);
+      switch (suffix) {
+        case "d":
+        case "":
+          arithmetic = { type: "days", amount: numAmount };
+          break;
+        case "m":
+          arithmetic = { type: "months", amount: numAmount };
+          break;
+        case "y":
+          arithmetic = { type: "years", amount: numAmount };
+          break;
+        default:
+          arithmetic = { type: "days", amount: numAmount };
+      }
+    } else if (arithmeticPart !== "") {
+      return { arithmetic: null, format: null, isValid: false };
     }
-    throw error;
   }
+  return { arithmetic, format, isValid: true };
 }
-function loadFileContent(filePath, context) {
-  if (context.contentCache.has(filePath)) {
-    return context.contentCache.get(filePath);
-  }
-  try {
-    if (existsSync(filePath)) ;
-  } catch (error) {
-    if (context.debug) {
-      console.warn(`[remarkImports] Failed to load import file "${filePath}":`, error);
-    }
+function applyDateArithmetic(baseDate, arithmetic) {
+  if (!arithmetic) return baseDate;
+  switch (arithmetic.type) {
+    case "days":
+      return addDays(baseDate, arithmetic.amount);
+    case "months":
+      return addMonths(baseDate, arithmetic.amount);
+    case "years":
+      return addYears(baseDate, arithmetic.amount);
+    default:
+      return baseDate;
   }
-  return null;
 }
-function extractSection(content, sectionName, debug) {
-  const lines = content.split("\n");
-  let sectionStart = -1;
-  let sectionEnd = lines.length;
-  let sectionLevel = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headerMatch) {
-      const [, hashes, title] = headerMatch;
-      const level = hashes.length;
-      if (title.toLowerCase() === sectionName.toLowerCase()) {
-        sectionStart = i + 1;
-        sectionLevel = level;
-        if (debug) {
-          console.log(`[remarkImports] Found section '${sectionName}' at line ${i}`);
-        }
-        break;
-      }
-    }
+function getOrdinalSuffix(day) {
+  if (day >= 11 && day <= 13) {
+    return "th";
   }
-  if (sectionStart === -1) {
-    if (debug) {
-      console.warn(`[remarkImports] Section '${sectionName}' not found`);
-    }
-    return content;
+  switch (day % 10) {
+    case 1:
+      return "st";
+    case 2:
+      return "nd";
+    case 3:
+      return "rd";
+    default:
+      return "th";
   }
-  for (let i = sectionStart; i < lines.length; i++) {
-    const line = lines[i].trim();
-    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headerMatch) {
-      const [, hashes] = headerMatch;
-      const level = hashes.length;
-      if (level <= sectionLevel) {
-        sectionEnd = i;
-        break;
-      }
+}
+function formatDateBasic(date, format) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const dayNumber = date.getDate();
+  const monthNames = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  switch (format.toLowerCase()) {
+    case "iso":
+    case "yyyy-mm-dd":
+      return `${year}-${month}-${day}`;
+    case "us":
+    case "mm/dd/yyyy":
+      return `${month}/${day}/${year}`;
+    case "eu":
+    case "european":
+    case "dd/mm/yyyy":
+      return `${day}/${month}/${year}`;
+    case "long":
+      return `${monthNames[date.getMonth()]} ${dayNumber}, ${year}`;
+    case "medium":
+      return `${monthNames[date.getMonth()].substring(0, 3)} ${dayNumber}, ${year}`;
+    case "short":
+      return `${monthNames[date.getMonth()].substring(0, 3)} ${dayNumber}, ${String(year).substring(2)}`;
+    case "legal": {
+      const suffix = getOrdinalSuffix(dayNumber);
+      return `${monthNames[date.getMonth()]} ${dayNumber}${suffix}, ${year}`;
     }
+    default:
+      return `${year}-${month}-${day}`;
   }
-  return lines.slice(sectionStart, sectionEnd).join("\n").trim();
-}
-function expandMixinsWithTracking(content, metadata) {
-  const mixinPattern = /\{\{([^}]+)\}\}/g;
-  return content.replace(mixinPattern, (match, fieldExpression) => {
-    const trimmedField = fieldExpression.trim();
-    let value;
-    let hasValue = false;
-    try {
-      const expandedValue = processMixins(match, metadata, {});
-      if (expandedValue !== match) {
-        value = expandedValue;
-        hasValue = true;
-      }
-    } catch (error) {
-    }
-    if (hasValue) {
-      const hasLogic = FUNCTION_CALL_PATTERN.test(trimmedField) || // Function call: formatPercent(...)
-      CONDITIONAL_PATTERN.test(trimmedField);
-      const cssClass = hasLogic ? "legal-field highlight" : "legal-field imported-value";
-      return `<span class="${cssClass}" data-field="${trimmedField}">${value}</span>`;
-    } else {
-      return match;
-    }
-  });
 }
-function stripHtmlComments(content) {
-  let processed = content;
-  processed = processed.replace(/<!--[\s\S]*?-->/g, "");
-  const headerPattern = `l{1,${MAX_HEADER_LEVEL}}`;
-  processed = processed.replace(
-    new RegExp(
-      `<(p|div|span)(?!\\s+[a-z])\\s*>\\s*(${headerPattern}\\.\\s+[^\\n]+)\\s*<\\/\\1>`,
-      "gi"
-    ),
-    "$2"
-  );
-  processed = processed.replace(
-    new RegExp(`<(p|div|span)(?!\\s+[a-z])\\s*>(${headerPattern}\\.\\s+[^<]+)<\\/\\1>`, "gi"),
-    "$2"
-  );
-  return processed;
+function getDateFieldCssClass(hasArithmetic) {
+  return hasArithmetic ? "legal-field highlight" : "legal-field imported-value";
 }
-function processNestedImports(content, context) {
-  const importDirectives = extractImportDirectives(content);
-  let processedContent = content;
-  if (importDirectives.length > 0) {
-    for (let i = importDirectives.length - 1; i >= 0; i--) {
-      const directive = importDirectives[i];
-      const result = processImportDirective(directive, context);
-      processedContent = processedContent.substring(0, directive.start) + result + processedContent.substring(directive.end);
-    }
-  }
-  if (context.mergeMetadata && Object.keys(context.accumulatedMetadata).length > 0) {
-    processedContent = expandMixinsWithTracking(processedContent, context.accumulatedMetadata);
+function formatDateValue(value, originalToken, enableFieldTracking = false, hasArithmetic = false) {
+  if (!enableFieldTracking) {
+    return value;
   }
-  return stripHtmlComments(processedContent);
-}
-
-const LEGAL_HEADER_PATTERN = /^(l{1,9})\.\s+(.+)$/;
-function getHeadingLevel(pattern) {
-  return pattern.length;
+  const cssClass = getDateFieldCssClass(hasArithmetic);
+  const fieldName = `date.${originalToken.replace(/[@[\]]/g, "")}`;
+  return `<span class="${cssClass}" data-field="${fieldName.replace(/"/g, "&quot;")}">${value}</span>`;
 }
-function isLegalHeader(node) {
-  if (node.children.length === 1 && node.children[0].type === "text") {
-    const textNode = node.children[0];
-    const match = textNode.value.match(LEGAL_HEADER_PATTERN);
-    if (match) {
-      const [, levelPattern, headerText] = match;
-      return {
-        level: getHeadingLevel(levelPattern),
-        text: headerText.trim()
-      };
+function processDateReferencesInAST(root, metadata, enableFieldTracking = false) {
+  visit(root, "text", (node, index, parent) => {
+    const originalValue = node.value;
+    let modifiedValue = originalValue;
+    let hasChanges = false;
+    modifiedValue = modifiedValue.replace(EXTENDED_DATE_PATTERN, (match, token) => {
+      try {
+        const { arithmetic, format: tokenFormat, isValid } = parseDateToken(token);
+        if (!isValid) {
+          return match;
+        }
+        let date = /* @__PURE__ */ new Date();
+        const hasArithmetic = !!arithmetic;
+        if (arithmetic) {
+          date = applyDateArithmetic(date, arithmetic);
+        }
+        const format = tokenFormat || metadata["date-format"] || "YYYY-MM-DD";
+        const formattedDate = formatDateBasic(date, format);
+        fieldTracker.trackField(`date.${match.replace(/[@[\]]/g, "")}`, {
+          value: formattedDate,
+          originalValue: match,
+          hasLogic: hasArithmetic
+        });
+        hasChanges = true;
+        return formatDateValue(formattedDate, match, enableFieldTracking, hasArithmetic);
+      } catch (error) {
+        console.warn(`Error processing date reference ${match}:`, error);
+        return match;
+      }
+    });
+    if (hasChanges) {
+      if (enableFieldTracking && modifiedValue.includes("<span")) {
+        if (parent && typeof index === "number") {
+          const htmlNode = {
+            type: "html",
+            value: modifiedValue
+          };
+          parent.children[index] = htmlNode;
+        }
+      } else {
+        node.value = modifiedValue;
+      }
     }
-  }
-  if (node.children.length > 0 && node.children[0].type === "text") {
-    const firstChild = node.children[0];
-    const match = firstChild.value.match(/^(l{1,5})\.\s*/);
-    if (match) {
-      const [fullMatch, levelPattern] = match;
-      const remainingText = firstChild.value.slice(fullMatch.length);
-      const otherText = node.children.slice(1).map((child) => {
-        if (child.type === "text") return child.value;
-        if (child.type === "html") return child.value || "";
-        return "";
-      }).join("");
-      return {
-        level: getHeadingLevel(levelPattern),
-        text: (remainingText + otherText).trim()
-      };
+  });
+  visit(root, "html", (node) => {
+    if (!node.value || !node.value.includes("@today")) {
+      return;
     }
-  }
-  return null;
-}
-function convertToHeading(node, level, text) {
-  const heading = {
-    type: "heading",
-    depth: level,
-    children: parseMarkdownInlineFormatting(text)
-  };
-  heading.data = { isLegalHeader: true };
-  if (node.children.length > 1 || node.children[0].type === "text" && node.children[0].value.includes("<span")) {
-    const firstChild = node.children[0];
-    if (firstChild.type === "text") {
-      const match = firstChild.value.match(/^(l{1,5})\.\s*/);
-      if (match) {
-        const [fullMatch] = match;
-        firstChild.value = firstChild.value.slice(fullMatch.length);
-        heading.children = node.children.filter((child) => {
-          if (child.type === "text" && child.value.trim() === "") {
-            return false;
+    let modifiedValue = node.value;
+    let hasChanges = false;
+    modifiedValue = modifiedValue.replace(
+      EXTENDED_DATE_PATTERN,
+      (match, formatOverride) => {
+        try {
+          const date = /* @__PURE__ */ new Date();
+          const format = formatOverride || metadata["date-format"] || "YYYY-MM-DD";
+          const formattedDate = formatDateBasic(date, format);
+          fieldTracker.trackField(`date.${match.replace(/[@[\]]/g, "")}`, {
+            value: formattedDate,
+            originalValue: match,
+            hasLogic: false
+          });
+          hasChanges = true;
+          if (enableFieldTracking) {
+            const cssClass = getDateFieldCssClass(false);
+            const fieldName = `date.${match.replace(/[@[\]]/g, "")}`;
+            return `<span class="${cssClass}" data-field="${fieldName.replace(/"/g, "&quot;")}">${formattedDate}</span>`;
+          } else {
+            return formattedDate;
           }
-          return true;
-        });
+        } catch (error) {
+          console.warn(`Error processing date reference ${match}:`, error);
+          return match;
+        }
       }
+    );
+    if (hasChanges) {
+      node.value = modifiedValue;
     }
-  }
-  return heading;
+  });
 }
-const remarkLegalHeadersParser = (options = {}) => {
-  const { debug = false } = options;
+const remarkDates = (options) => {
+  const { metadata, debug = false, enableFieldTracking = false } = options;
   return (tree) => {
     if (debug) {
-      console.log("🔍 [remarkLegalHeadersParser] Parsing legal header syntax");
+      console.log("📅 Processing date references with remark plugin");
     }
-    let convertedCount = 0;
-    const nodesToReplace = [];
-    visit(tree, "paragraph", (node, index, parent) => {
-      if (parent && typeof index === "number") {
-        if (node.children.length === 1 && node.children[0].type === "text") {
-          const textNode = node.children[0];
-          const lines = textNode.value.split("\n");
-          const hasLegalHeaders = lines.some((line) => LEGAL_HEADER_PATTERN.test(line));
-          if (hasLegalHeaders) {
-            const newNodes = [];
-            const nonHeaderLines = [];
-            for (const line of lines) {
-              const match = line.match(LEGAL_HEADER_PATTERN);
-              if (match) {
-                if (nonHeaderLines.length > 0) {
-                  newNodes.push({
-                    type: "paragraph",
-                    children: [
-                      {
-                        type: "text",
-                        value: nonHeaderLines.join("\n")
-                      }
-                    ]
-                  });
-                  nonHeaderLines.length = 0;
-                }
-                const [, levelPattern, headerText] = match;
-                const level = getHeadingLevel(levelPattern);
-                if (debug) {
-                  console.log(
-                    `🔄 [remarkLegalHeadersParser] Converting "${line.substring(0, 50)}..." to level ${level} heading`
-                  );
-                }
-                const headingNode = {
-                  type: "heading",
-                  depth: level,
-                  children: parseMarkdownInlineFormatting(headerText.trim())
-                };
-                headingNode.data = { isLegalHeader: true };
-                newNodes.push(headingNode);
-                convertedCount++;
-              } else {
-                nonHeaderLines.push(line);
-              }
-            }
-            if (nonHeaderLines.length > 0) {
-              newNodes.push({
-                type: "paragraph",
-                children: [
-                  {
-                    type: "text",
-                    value: nonHeaderLines.join("\n")
-                  }
-                ]
-              });
-            }
-            if (newNodes.length > 0) {
-              nodesToReplace.push({ parent, index, newNodes });
-            }
+    processDateReferencesInAST(tree, metadata, enableFieldTracking);
+    if (debug) {
+      console.log("✅ Date reference processing completed");
+    }
+  };
+};
+
+class PluginOrderValidator {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Validate plugin execution order
+   *
+   * @param pluginNames - List of plugin names in execution order
+   * @param options - Validation options
+   * @returns Validation result with errors and warnings
+   */
+  validate(pluginNames, options = {}) {
+    const { throwOnError = true, logWarnings = true, strictMode = false, debug = false } = options;
+    const errors = [];
+    const warnings = [];
+    if (debug) {
+      console.log("[PluginOrderValidator] Validating plugin order:", pluginNames);
+    }
+    const positions = /* @__PURE__ */ new Map();
+    pluginNames.forEach((name, index) => {
+      positions.set(name, index);
+    });
+    for (let i = 0; i < pluginNames.length; i++) {
+      const pluginName = pluginNames[i];
+      const metadata = this.registry.get(pluginName);
+      if (!metadata) {
+        if (strictMode) {
+          warnings.push({
+            type: "unknown-plugin",
+            plugin: pluginName,
+            message: `Plugin "${pluginName}" has no metadata declaration`
+          });
+        }
+        continue;
+      }
+      if (debug) {
+        console.log(`[PluginOrderValidator] Checking constraints for ${pluginName}`);
+      }
+      if (metadata.runBefore) {
+        for (const beforePlugin of metadata.runBefore) {
+          const beforePos = positions.get(beforePlugin);
+          if (beforePos !== void 0 && beforePos <= i) {
+            errors.push({
+              type: "dependency-violation",
+              plugin: pluginName,
+              relatedPlugin: beforePlugin,
+              message: `"${pluginName}" must run BEFORE "${beforePlugin}", but it appears after it in the pipeline`
+            });
           }
-        } else if (node.children.length > 1) {
-          let fullText = "";
-          const childrenMap = /* @__PURE__ */ new Map();
-          for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            const start = fullText.length;
-            if (child.type === "text") {
-              fullText += child.value;
-            } else if (child.type === "emphasis") {
-              const emphasisText = child.children.map((c) => c.value || "").join("");
-              fullText += `_${emphasisText}_`;
-            } else if (child.type === "strong") {
-              const strongText = child.children.map((c) => c.value || "").join("");
-              fullText += `__${strongText}__`;
-            } else if (child.type === "link") {
-              const linkText = child.children.map((c) => c.value || "").join("");
-              const url = child.url || "";
-              fullText += `[${linkText}](${url})`;
-            } else if (child.type === "inlineCode") {
-              fullText += `\`${child.value || ""}\``;
-            } else {
-              fullText += child.value || "";
-            }
-            const end = fullText.length;
-            childrenMap.set(i, { start, end, child });
+        }
+      }
+      if (metadata.runAfter) {
+        for (const afterPlugin of metadata.runAfter) {
+          const afterPos = positions.get(afterPlugin);
+          if (afterPos !== void 0 && afterPos >= i) {
+            errors.push({
+              type: "dependency-violation",
+              plugin: pluginName,
+              relatedPlugin: afterPlugin,
+              message: `"${pluginName}" must run AFTER "${afterPlugin}", but it appears before it in the pipeline`
+            });
           }
-          const lines = fullText.split("\n");
-          const hasLegalHeaders = lines.some((line) => LEGAL_HEADER_PATTERN.test(line));
-          if (hasLegalHeaders) {
-            const newNodes = [];
-            const nonHeaderLines = [];
-            for (const line of lines) {
-              const match = line.match(LEGAL_HEADER_PATTERN);
-              if (match) {
-                if (nonHeaderLines.length > 0) {
-                  newNodes.push({
-                    type: "paragraph",
-                    children: [
-                      {
-                        type: "text",
-                        value: nonHeaderLines.join("\n")
-                      }
-                    ]
-                  });
-                  nonHeaderLines.length = 0;
-                }
-                const [, levelPattern, headerText] = match;
-                const level = getHeadingLevel(levelPattern);
-                if (debug) {
-                  console.log(
-                    `🔄 [remarkLegalHeadersParser] Converting complex "${line.substring(0, 50)}..." to level ${level} heading`
-                  );
-                }
-                const headingNode = {
-                  type: "heading",
-                  depth: level,
-                  children: parseMarkdownInlineFormatting(headerText.trim())
-                };
-                headingNode.data = { isLegalHeader: true };
-                newNodes.push(headingNode);
-                convertedCount++;
-              } else {
-                nonHeaderLines.push(line);
+        }
+      }
+      if (metadata.conflicts) {
+        for (const conflictPlugin of metadata.conflicts) {
+          if (positions.has(conflictPlugin)) {
+            errors.push({
+              type: "conflict",
+              plugin: pluginName,
+              relatedPlugin: conflictPlugin,
+              message: `"${pluginName}" conflicts with "${conflictPlugin}" - they cannot be used together`
+            });
+          }
+        }
+      }
+    }
+    for (const [name, metadata] of this.registry.entries()) {
+      if (metadata.required && !positions.has(name)) {
+        warnings.push({
+          type: "missing-required",
+          plugin: name,
+          message: `Required plugin "${name}" is missing from the pipeline`
+        });
+      }
+    }
+    const circularErrors = this.detectCircularDependencies(pluginNames);
+    errors.push(...circularErrors);
+    if (logWarnings && warnings.length > 0) {
+      for (const warning of warnings) {
+        console.warn(`[PluginOrderValidator] WARNING: ${warning.message}`);
+      }
+    }
+    const valid = errors.length === 0;
+    let suggestedOrder;
+    if (!valid) {
+      try {
+        suggestedOrder = this.topologicalSort(pluginNames);
+        if (debug) {
+          console.log("[PluginOrderValidator] Suggested order:", suggestedOrder);
+        }
+      } catch (error) {
+        if (debug) {
+          console.error("[PluginOrderValidator] Failed to generate suggested order:", error);
+        }
+      }
+    }
+    const result = {
+      valid,
+      errors,
+      warnings,
+      suggestedOrder
+    };
+    if (!valid && throwOnError) {
+      const errorMessages = errors.map((e) => e.message).join("\n  - ");
+      throw new Error(
+        `Plugin order validation failed:
+  - ${errorMessages}${suggestedOrder ? `
+
+Suggested order: ${suggestedOrder.join(" → ")}` : ""}`
+      );
+    }
+    return result;
+  }
+  /**
+   * Detect circular dependencies in plugin metadata
+   *
+   * @param pluginNames - List of plugin names
+   * @returns List of errors for circular dependencies found
+   */
+  detectCircularDependencies(pluginNames) {
+    const errors = [];
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const hasCycle = (plugin, path) => {
+      if (recursionStack.has(plugin)) {
+        const cyclePath = [...path, plugin].join(" → ");
+        errors.push({
+          type: "circular-dependency",
+          plugin,
+          message: `Circular dependency detected: ${cyclePath}`
+        });
+        return true;
+      }
+      if (visited.has(plugin)) {
+        return false;
+      }
+      visited.add(plugin);
+      recursionStack.add(plugin);
+      const metadata = this.registry.get(plugin);
+      if (metadata) {
+        if (metadata.runAfter) {
+          for (const dep of metadata.runAfter) {
+            if (pluginNames.includes(dep)) {
+              if (hasCycle(dep, [...path, plugin])) {
+                recursionStack.delete(plugin);
+                return true;
               }
             }
-            if (nonHeaderLines.length > 0) {
-              newNodes.push({
-                type: "paragraph",
-                children: [
-                  {
-                    type: "text",
-                    value: nonHeaderLines.join("\n")
-                  }
-                ]
-              });
-            }
-            if (newNodes.length > 0) {
-              nodesToReplace.push({ parent, index, newNodes });
-            }
           }
         }
-      } else {
-        if (debug) {
-          const firstChildText = node.children[0]?.type === "text" ? node.children[0].value : "<non-text>";
-          console.log(`🔍 [remarkLegalHeadersParser] Single-line paragraph: "${firstChildText}"`);
+      }
+      recursionStack.delete(plugin);
+      return false;
+    };
+    for (const plugin of pluginNames) {
+      if (!visited.has(plugin)) {
+        hasCycle(plugin, []);
+      }
+    }
+    return errors;
+  }
+  /**
+   * Perform topological sort on plugins to find a valid execution order
+   *
+   * Uses Kahn's algorithm for topological sorting.
+   *
+   * @param pluginNames - List of plugin names to sort
+   * @returns Sorted list of plugin names
+   * @throws Error if plugins have circular dependencies
+   */
+  topologicalSort(pluginNames) {
+    const adjList = /* @__PURE__ */ new Map();
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const plugin of pluginNames) {
+      adjList.set(plugin, /* @__PURE__ */ new Set());
+      inDegree.set(plugin, 0);
+    }
+    for (const plugin of pluginNames) {
+      const metadata = this.registry.get(plugin);
+      if (!metadata) continue;
+      if (metadata.runBefore) {
+        for (const beforePlugin of metadata.runBefore) {
+          if (pluginNames.includes(beforePlugin)) {
+            adjList.get(plugin).add(beforePlugin);
+            inDegree.set(beforePlugin, inDegree.get(beforePlugin) + 1);
+          }
         }
-        const headerInfo = isLegalHeader(node);
-        if (headerInfo && parent && typeof index === "number") {
-          if (debug) {
-            const firstChildText = node.children[0].type === "text" ? node.children[0].value : "";
-            console.log(
-              `🔄 [remarkLegalHeadersParser] Converting "${firstChildText.substring(0, 50)}..." to level ${headerInfo.level} heading`
-            );
+      }
+      if (metadata.runAfter) {
+        for (const afterPlugin of metadata.runAfter) {
+          if (pluginNames.includes(afterPlugin)) {
+            adjList.get(afterPlugin).add(plugin);
+            inDegree.set(plugin, inDegree.get(plugin) + 1);
           }
-          const heading = convertToHeading(node, headerInfo.level, headerInfo.text);
-          nodesToReplace.push({ parent, index, newNodes: [heading] });
-          convertedCount++;
         }
       }
-    });
-    for (let i = nodesToReplace.length - 1; i >= 0; i--) {
-      const { parent, index, newNodes } = nodesToReplace[i];
-      parent.children.splice(index, 1, ...newNodes);
     }
-    if (debug) {
-      console.log(`✅ [remarkLegalHeadersParser] Converted ${convertedCount} legal headers`);
+    const queue = [];
+    const result = [];
+    for (const [plugin, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(plugin);
+      }
     }
-  };
+    while (queue.length > 0) {
+      const current = queue.shift();
+      result.push(current);
+      for (const neighbor of adjList.get(current)) {
+        const newDegree = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    if (result.length !== pluginNames.length) {
+      throw new Error("Cannot generate topological sort: circular dependencies detected");
+    }
+    return result;
+  }
+  /**
+   * Get metadata for a plugin
+   *
+   * @param pluginName - Name of the plugin
+   * @returns Plugin metadata or undefined if not found
+   */
+  getMetadata(pluginName) {
+    return this.registry.get(pluginName);
+  }
+  /**
+   * Add or update metadata for a plugin
+   *
+   * @param metadata - Plugin metadata to add/update
+   */
+  registerPlugin(metadata) {
+    this.registry.set(metadata.name, metadata);
+  }
+}
+function createPluginRegistry(metadataList) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const metadata of metadataList) {
+    registry.set(metadata.name, metadata);
+  }
+  return registry;
+}
+
+const PLUGIN_METADATA_LIST = [
+  // Phase 1: Import Processing
+  {
+    name: "remarkImports",
+    description: "Process @import directives and insert content as AST nodes",
+    runBefore: [
+      "remarkTemplateFields",
+      "remarkLegalHeadersParser",
+      "remarkFieldTracking",
+      "remarkMixins"
+    ],
+    required: false,
+    version: "2.0.0"
+    // Version 2.0 uses AST-based insertion
+  },
+  // Phase 2: Mixin and Field Processing
+  {
+    name: "remarkMixins",
+    description: "Process mixin definitions and expansions",
+    runAfter: ["remarkImports"],
+    runBefore: ["remarkTemplateFields"],
+    required: false
+  },
+  {
+    name: "remarkTemplateFields",
+    description: "Process {{field}} template patterns and resolve values",
+    runAfter: ["remarkImports", "remarkMixins"],
+    runBefore: ["remarkFieldTracking"],
+    required: true
+  },
+  // Phase 3: Header Processing
+  {
+    name: "remarkLegalHeadersParser",
+    description: "Parse legal header markers (l., ll., lll.) into structured headers",
+    runAfter: ["remarkImports"],
+    runBefore: ["remarkHeaders"],
+    required: true
+  },
+  {
+    name: "remarkHeaders",
+    description: "Process headers and add CSS classes (legal-header-level-X)",
+    runAfter: ["remarkLegalHeadersParser"],
+    required: true
+  },
+  // Phase 4: Field Tracking
+  {
+    name: "remarkFieldTracking",
+    description: "Track template fields for highlighting and analysis",
+    runAfter: ["remarkTemplateFields"],
+    required: false
+  },
+  // Phase 5: Cross-References and Clauses
+  {
+    name: "remarkCrossReferences",
+    description: "Process cross-references between document sections",
+    // Must run BEFORE remarkHeaders to extract |key| patterns before headers removes them
+    runBefore: ["remarkHeaders"],
+    runAfter: ["remarkLegalHeadersParser"],
+    // After headers are parsed, before they're processed
+    required: false
+  },
+  {
+    name: "remarkCrossReferencesAst",
+    description: "AST-based cross-reference processing (alternative to remarkCrossReferences)",
+    runAfter: ["remarkHeaders", "remarkLegalHeadersParser"],
+    conflicts: ["remarkCrossReferences"],
+    // Can't use both
+    required: false
+  },
+  {
+    name: "remarkClauses",
+    description: "Process conditional clauses ({{#if}}, {{#unless}})",
+    // Note: Can run before or after remarkTemplateFields depending on use case
+    required: false
+  },
+  // Phase 6: Date Processing
+  {
+    name: "remarkDates",
+    description: "Process date fields and formatting",
+    // Note: Can run before or after remarkTemplateFields depending on use case
+    required: false
+  },
+  // Phase 7: Signature Lines
+  {
+    name: "remarkSignatureLines",
+    description: "Process signature line markers",
+    required: false
+  },
+  // Utility Plugins
+  {
+    name: "remarkDebugAst",
+    description: "Debug plugin for visualizing AST structure",
+    required: false
+  }
+];
+const GLOBAL_PLUGIN_REGISTRY = createPluginRegistry(PLUGIN_METADATA_LIST);
+
+const DEFAULT_OPTIONS = {
+  minUnderscores: 10,
+  addCssClass: true,
+  cssClassName: "signature-line",
+  debug: false
 };
-function parseMarkdownInlineFormatting(text) {
-  const children = [];
-  const patterns = [
-    { regex: /\[([^\]]+)\]\([^)]+\)/g, type: "link" },
-    // [text](url) - extract just the text
-    { regex: /`([^`]+)`/g, type: "inlineCode" },
-    // `code`
-    { regex: /\*\*(.+?)\*\*/g, type: "strong" },
-    // **bold**
-    { regex: /__(.+?)__/g, type: "strong" },
-    // __bold__
-    { regex: /\*(.+?)\*/g, type: "emphasis" },
-    // *italic*
-    { regex: /_(.+?)_/g, type: "emphasis" }
-    // _italic_
-  ];
-  const allMatches = [];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.regex.exec(text)) !== null) {
-      allMatches.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        type: pattern.type,
-        content: match[1]
+function sanitizeCssClassName(className) {
+  const validPattern = /^[a-zA-Z_][\w-]*$/;
+  if (!className || !validPattern.test(className)) {
+    console.warn(
+      `[signature-lines] Invalid CSS class name "${className}", using default "signature-line"`
+    );
+    return "signature-line";
+  }
+  return className;
+}
+const remarkSignatureLines = (options = {}) => {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  const safeCssClassName = sanitizeCssClassName(config.cssClassName);
+  return (tree) => {
+    if (config.debug) {
+      console.log("[signature-lines] Processing tree...");
+    }
+    visit(tree, "text", (node, index, parent) => {
+      if (index === void 0 || !parent) return;
+      const text = node.value;
+      const underscorePattern = new RegExp(`_{${config.minUnderscores},}`, "g");
+      if (!underscorePattern.test(text)) {
+        return;
+      }
+      if (config.debug) {
+        console.log("[signature-lines] Found signature line in text:", text);
+      }
+      if (!config.addCssClass) {
+        return;
+      }
+      const processedText = text.replace(underscorePattern, (match) => {
+        if (config.debug) {
+          console.log(`[signature-lines] Wrapping ${match.length} underscores`);
+        }
+        return `<span class="${safeCssClassName}">${match}</span>`;
       });
+      const htmlNode = {
+        type: "html",
+        value: processedText
+      };
+      parent.children[index] = htmlNode;
+    });
+    if (config.debug) {
+      console.log("[signature-lines] Processing complete");
     }
+  };
+};
+
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function processTemplateLoops(content, metadata, context, enableFieldTracking = true) {
+  const loopBlocks = findLoopBlocks(content);
+  if (loopBlocks.length === 0) {
+    return content;
   }
-  allMatches.sort((a, b) => a.start - b.start);
-  const validMatches = [];
-  let lastEnd = 0;
-  for (const match of allMatches) {
-    if (match.start >= lastEnd) {
-      validMatches.push(match);
-      lastEnd = match.end;
-    }
+  let processedContent = content;
+  for (let i = loopBlocks.length - 1; i >= 0; i--) {
+    const loopBlock = loopBlocks[i];
+    const expandedContent = expandLoopBlock(loopBlock, metadata, context, enableFieldTracking);
+    processedContent = processedContent.slice(0, loopBlock.start) + expandedContent + processedContent.slice(loopBlock.end);
   }
-  let pos = 0;
-  for (const match of validMatches) {
-    if (pos < match.start) {
-      const beforeText = text.slice(pos, match.start);
-      if (beforeText) {
-        children.push({
-          type: "text",
-          value: beforeText
-        });
-      }
-    }
-    if (match.type === "inlineCode") {
-      children.push({
-        type: "inlineCode",
-        value: match.content
-      });
-    } else if (match.type === "link") {
-      children.push({
-        type: "text",
-        value: match.content
-      });
+  return processedContent;
+}
+function findLoopBlocks(content) {
+  const loopBlocks = [];
+  const loopPattern = /\{\{#([\w.]+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+  const conditionalPattern = /\{\{#if\s*([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g;
+  let match;
+  while ((match = loopPattern.exec(content)) !== null) {
+    const [fullMatch, variable, loopContent] = match;
+    loopBlocks.push({
+      variable,
+      content: loopContent,
+      start: match.index,
+      end: match.index + fullMatch.length,
+      fullMatch
+    });
+  }
+  while ((match = conditionalPattern.exec(content)) !== null) {
+    const [fullMatch, condition, conditionalContent] = match;
+    loopBlocks.push({
+      variable: `if ${condition}`,
+      // Mark as conditional
+      content: conditionalContent,
+      start: match.index,
+      end: match.index + fullMatch.length,
+      fullMatch
+    });
+  }
+  return loopBlocks;
+}
+function expandLoopBlock(loopBlock, metadata, parentContext, enableFieldTracking = true) {
+  const { variable, content } = loopBlock;
+  if (variable.startsWith("if ")) {
+    const condition = variable.substring(3).trim();
+    const conditionValue = evaluateCondition(condition, metadata);
+    fieldTracker.trackField(`if ${condition}`, {
+      value: conditionValue,
+      hasLogic: true,
+      mixinUsed: "conditional"
+    });
+    const elseIndex = content.indexOf("{{else}}");
+    if (elseIndex !== -1) {
+      const ifContent = content.substring(0, elseIndex);
+      const elseContent = content.substring(elseIndex + 8);
+      const selectedContent = conditionValue ? ifContent : elseContent;
+      return processTemplateContent(selectedContent, metadata, parentContext, enableFieldTracking);
     } else {
-      children.push({
-        type: match.type,
-        children: [
-          {
-            type: "text",
-            value: match.content
-          }
-        ]
-      });
+      if (conditionValue) {
+        return processTemplateContent(content, metadata, parentContext, enableFieldTracking);
+      } else {
+        return "";
+      }
     }
-    pos = match.end;
   }
-  if (pos < text.length) {
-    const remainingText = text.slice(pos);
-    if (remainingText) {
-      children.push({
-        type: "text",
-        value: remainingText
-      });
-    }
+  const loopValue = resolveLoopVariable(variable, metadata, parentContext);
+  fieldTracker.trackField(variable, {
+    value: loopValue,
+    hasLogic: true,
+    mixinUsed: "loop"
+  });
+  if (Array.isArray(loopValue)) {
+    return expandArrayLoop(
+      variable,
+      content,
+      loopValue,
+      metadata,
+      parentContext,
+      enableFieldTracking
+    );
+  } else if (loopValue) {
+    return expandConditionalBlock(
+      variable,
+      content,
+      loopValue,
+      metadata,
+      parentContext,
+      enableFieldTracking
+    );
+  } else {
+    return "";
   }
-  if (children.length === 0) {
-    return [
-      {
-        type: "text",
-        value: text
-      }
-    ];
+}
+function expandArrayLoop(variable, content, items, metadata, parentContext, enableFieldTracking = true) {
+  const expandedParts = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const loopContext = {
+      variable,
+      item,
+      index: i,
+      total: items.length,
+      parent: parentContext
+    };
+    const enhancedMetadata = createEnhancedMetadata(metadata, item, loopContext);
+    let processedContent = content;
+    processedContent = processTemplateLoops(
+      processedContent,
+      enhancedMetadata,
+      loopContext,
+      enableFieldTracking
+    );
+    processedContent = processItemMixins(
+      processedContent,
+      enhancedMetadata,
+      loopContext,
+      enableFieldTracking
+    );
+    processedContent = convertMarkdownListToHtml(processedContent);
+    expandedParts.push(processedContent);
   }
-  return children;
+  return expandedParts.join("\n");
 }
-
-const EXTENDED_DATE_PATTERN = /@today((?:[+-]\d+[dmy]?(?:\[[^\]]+\])?)|(?:[+-]\d+[dmy]?)|(?:\[[^\]]+\]))?/g;
-function parseDateToken(token) {
-  if (!token) return { arithmetic: null, format: null, isValid: true };
-  if (!/^[+-]?\d*[dmy]?(\[[^\]]+\])?$/.test(token)) {
-    return { arithmetic: null, format: null, isValid: false };
+function expandConditionalBlock(variable, content, value, metadata, parentContext, enableFieldTracking = true) {
+  const enhancedMetadata = {
+    ...metadata,
+    [variable]: value
+  };
+  let processedContent = processTemplateLoops(
+    content,
+    enhancedMetadata,
+    parentContext,
+    enableFieldTracking
+  );
+  processedContent = processItemMixins(
+    processedContent,
+    enhancedMetadata,
+    parentContext,
+    enableFieldTracking
+  );
+  return processedContent;
+}
+function resolveLoopVariable(variable, metadata, parentContext) {
+  const resolvedFromMetadata = resolvePath(metadata, variable);
+  if (resolvedFromMetadata !== void 0) {
+    return resolvedFromMetadata;
   }
-  const formatMatch = token.match(/\[([^\]]+)\]/);
-  const format = formatMatch ? formatMatch[1] : null;
-  const arithmeticPart = token.replace(/\[([^\]]+)\]/, "");
-  let arithmetic = null;
-  if (arithmeticPart) {
-    const arithmeticMatch = arithmeticPart.match(/^([+-])(\d+)([dmy]?)$/);
-    if (arithmeticMatch) {
-      const [, sign, amount, suffix] = arithmeticMatch;
-      const numAmount = parseInt(amount) * (sign === "-" ? -1 : 1);
-      switch (suffix) {
-        case "d":
-        case "":
-          arithmetic = { type: "days", amount: numAmount };
-          break;
-        case "m":
-          arithmetic = { type: "months", amount: numAmount };
-          break;
-        case "y":
-          arithmetic = { type: "years", amount: numAmount };
-          break;
-        default:
-          arithmetic = { type: "days", amount: numAmount };
+  if (parentContext && parentContext.item) {
+    const resolvedFromContext = resolvePath(parentContext.item, variable);
+    if (resolvedFromContext !== void 0) {
+      return resolvedFromContext;
+    }
+  }
+  let ctx = parentContext;
+  while (ctx && ctx.parent) {
+    ctx = ctx.parent;
+    if (ctx.item) {
+      const resolvedFromNestedContext = resolvePath(ctx.item, variable);
+      if (resolvedFromNestedContext !== void 0) {
+        return resolvedFromNestedContext;
       }
-    } else if (arithmeticPart !== "") {
-      return { arithmetic: null, format: null, isValid: false };
     }
   }
-  return { arithmetic, format, isValid: true };
+  return void 0;
 }
-function applyDateArithmetic(baseDate, arithmetic) {
-  if (!arithmetic) return baseDate;
-  switch (arithmetic.type) {
-    case "days":
-      return addDays(baseDate, arithmetic.amount);
-    case "months":
-      return addMonths(baseDate, arithmetic.amount);
-    case "years":
-      return addYears(baseDate, arithmetic.amount);
-    default:
-      return baseDate;
+function createEnhancedMetadata(metadata, item, context) {
+  const enhanced = { ...metadata };
+  if (item && typeof item === "object" && !Array.isArray(item)) {
+    Object.assign(enhanced, item);
   }
+  enhanced["."] = item;
+  enhanced["@index"] = context.index;
+  enhanced["@total"] = context.total;
+  enhanced["@first"] = context.index === 0;
+  enhanced["@last"] = context.index === context.total - 1;
+  return enhanced;
 }
-function getOrdinalSuffix(day) {
-  if (day >= 11 && day <= 13) {
-    return "th";
-  }
-  switch (day % 10) {
-    case 1:
-      return "st";
-    case 2:
-      return "nd";
-    case 3:
-      return "rd";
-    default:
-      return "th";
+function evaluateHelperExpression(expression, metadata) {
+  try {
+    const match = expression.match(/^(\w+)\((.*)\)$/);
+    if (!match) return void 0;
+    const [, helperName, argsString] = match;
+    const helper = extensionHelpers[helperName];
+    if (!helper || typeof helper !== "function") {
+      return void 0;
+    }
+    const args = argsString ? parseHelperArguments(argsString, metadata) : [];
+    return helper(...args);
+  } catch (error) {
+    console.error(`Error evaluating helper expression: ${expression}`, error);
+    return void 0;
   }
 }
-function formatDateBasic(date, format) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const dayNumber = date.getDate();
-  const monthNames = [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December"
-  ];
-  switch (format.toLowerCase()) {
-    case "iso":
-    case "yyyy-mm-dd":
-      return `${year}-${month}-${day}`;
-    case "us":
-    case "mm/dd/yyyy":
-      return `${month}/${day}/${year}`;
-    case "eu":
-    case "european":
-    case "dd/mm/yyyy":
-      return `${day}/${month}/${year}`;
-    case "long":
-      return `${monthNames[date.getMonth()]} ${dayNumber}, ${year}`;
-    case "medium":
-      return `${monthNames[date.getMonth()].substring(0, 3)} ${dayNumber}, ${year}`;
-    case "short":
-      return `${monthNames[date.getMonth()].substring(0, 3)} ${dayNumber}, ${String(year).substring(2)}`;
-    case "legal": {
-      const suffix = getOrdinalSuffix(dayNumber);
-      return `${monthNames[date.getMonth()]} ${dayNumber}${suffix}, ${year}`;
+function parseHelperArguments(argsString, metadata) {
+  const args = [];
+  let currentArg = "";
+  let parenDepth = 0;
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < argsString.length; i++) {
+    const char = argsString[i];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+      currentArg += char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+      currentArg += char;
+    } else if (char === "(" && !inQuotes) {
+      parenDepth++;
+      currentArg += char;
+    } else if (char === ")" && !inQuotes) {
+      parenDepth--;
+      currentArg += char;
+    } else if (char === "," && parenDepth === 0 && !inQuotes) {
+      args.push(resolveHelperArgument(currentArg.trim(), metadata));
+      currentArg = "";
+    } else {
+      currentArg += char;
     }
-    default:
-      return `${year}-${month}-${day}`;
   }
+  if (currentArg.trim()) {
+    args.push(resolveHelperArgument(currentArg.trim(), metadata));
+  }
+  return args;
 }
-function getDateFieldCssClass(hasArithmetic) {
-  return hasArithmetic ? "legal-field highlight" : "legal-field imported-value";
+function resolveHelperArgument(arg, metadata) {
+  if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
+    return arg.slice(1, -1);
+  }
+  if (arg === "true") return true;
+  if (arg === "false") return false;
+  if (/^\d+$/.test(arg)) {
+    return parseInt(arg, 10);
+  }
+  if (/^\d+\.\d+$/.test(arg)) {
+    return parseFloat(arg);
+  }
+  if (arg === "@today") {
+    return metadata["@today"] ? new Date(metadata["@today"]) : /* @__PURE__ */ new Date();
+  }
+  if (arg.includes("(") && arg.includes(")")) {
+    const result = evaluateHelperExpression(arg, metadata);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  return resolvePath(metadata, arg);
 }
-function formatDateValue(value, originalToken, enableFieldTracking = false, hasArithmetic = false) {
-  if (!enableFieldTracking) {
-    return value;
+function resolvePath(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
   }
-  const cssClass = getDateFieldCssClass(hasArithmetic);
-  const fieldName = `date.${originalToken.replace(/[@[\]]/g, "")}`;
-  return `<span class="${cssClass}" data-field="${fieldName.replace(/"/g, "&quot;")}">${value}</span>`;
+  return current;
 }
-function processDateReferencesInAST(root, metadata, enableFieldTracking = false) {
-  visit(root, "text", (node, index, parent) => {
-    const originalValue = node.value;
-    let modifiedValue = originalValue;
-    let hasChanges = false;
-    modifiedValue = modifiedValue.replace(EXTENDED_DATE_PATTERN, (match, token) => {
-      try {
-        const { arithmetic, format: tokenFormat, isValid } = parseDateToken(token);
-        if (!isValid) {
-          return match;
-        }
-        let date = /* @__PURE__ */ new Date();
-        const hasArithmetic = !!arithmetic;
-        if (arithmetic) {
-          date = applyDateArithmetic(date, arithmetic);
-        }
-        const format = tokenFormat || metadata["date-format"] || "YYYY-MM-DD";
-        const formattedDate = formatDateBasic(date, format);
-        fieldTracker.trackField(`date.${match.replace(/[@[\]]/g, "")}`, {
-          value: formattedDate,
-          originalValue: match,
-          hasLogic: hasArithmetic
-        });
-        hasChanges = true;
-        return formatDateValue(formattedDate, match, enableFieldTracking, hasArithmetic);
-      } catch (error) {
-        console.warn(`Error processing date reference ${match}:`, error);
-        return match;
-      }
-    });
-    if (hasChanges) {
-      if (enableFieldTracking && modifiedValue.includes("<span")) {
-        if (parent && typeof index === "number") {
-          const htmlNode = {
-            type: "html",
-            value: modifiedValue
-          };
-          parent.children[index] = htmlNode;
-        }
-      } else {
-        node.value = modifiedValue;
+function processItemMixins(content, metadata, context, enableFieldTracking = true) {
+  const mixinPattern = /\{\{([^}]+)\}\}/g;
+  return content.replace(mixinPattern, (match, variable) => {
+    const trimmedVar = variable.trim();
+    if (trimmedVar.includes("?") && trimmedVar.includes(":")) {
+      const result = processConditionalExpression(trimmedVar, metadata, enableFieldTracking);
+      if (enableFieldTracking) {
+        return `<span class="highlight">${result}</span>`;
       }
+      return result;
     }
-  });
-  visit(root, "html", (node) => {
-    if (!node.value || !node.value.includes("@today")) {
-      return;
-    }
-    let modifiedValue = node.value;
-    let hasChanges = false;
-    modifiedValue = modifiedValue.replace(
-      EXTENDED_DATE_PATTERN,
-      (match, formatOverride) => {
-        try {
-          const date = /* @__PURE__ */ new Date();
-          const format = formatOverride || metadata["date-format"] || "YYYY-MM-DD";
-          const formattedDate = formatDateBasic(date, format);
-          fieldTracker.trackField(`date.${match.replace(/[@[\]]/g, "")}`, {
-            value: formattedDate,
-            originalValue: match,
-            hasLogic: false
-          });
-          hasChanges = true;
-          if (enableFieldTracking) {
-            const cssClass = getDateFieldCssClass(false);
-            const fieldName = `date.${match.replace(/[@[\]]/g, "")}`;
-            return `<span class="${cssClass}" data-field="${fieldName.replace(/"/g, "&quot;")}">${formattedDate}</span>`;
-          } else {
-            return formattedDate;
-          }
-        } catch (error) {
-          console.warn(`Error processing date reference ${match}:`, error);
-          return match;
+    if (trimmedVar.includes("(") && trimmedVar.includes(")")) {
+      const result = evaluateHelperExpression(trimmedVar, metadata);
+      if (result !== void 0) {
+        fieldTracker.trackField(trimmedVar, {
+          value: result,
+          hasLogic: true,
+          mixinUsed: "helper"
+        });
+        if (enableFieldTracking) {
+          const escapedField = escapeHtmlAttribute(trimmedVar);
+          const stringResult = String(result);
+          return `<span class="highlight"><span class="imported-value" data-field="${escapedField}">${stringResult}</span></span>`;
         }
+        return String(result);
       }
-    );
-    if (hasChanges) {
-      node.value = modifiedValue;
     }
+    const value = resolveVariablePath(trimmedVar, metadata);
+    if (value === void 0 || value === null) {
+      if (enableFieldTracking) {
+        return `<span class="legal-field missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span>`;
+      }
+      return `{{${trimmedVar}}}`;
+    }
+    if (enableFieldTracking) {
+      return `<span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${String(value)}</span>`;
+    }
+    return String(value);
   });
 }
-const remarkDates = (options) => {
-  const { metadata, debug = false, enableFieldTracking = false } = options;
-  return (tree) => {
-    if (debug) {
-      console.log("📅 Processing date references with remark plugin");
+function processConditionalExpression(expression, metadata, enableFieldTracking = true) {
+  const questionIndex = findOperatorIndex(expression, "?");
+  const colonIndex = findOperatorIndex(expression, ":", questionIndex);
+  if (questionIndex === -1 || colonIndex === -1) {
+    return expression;
+  }
+  const condition = expression.substring(0, questionIndex).trim();
+  const truePart = expression.substring(questionIndex + 1, colonIndex).trim();
+  const falsePart = expression.substring(colonIndex + 1).trim();
+  const conditionValue = resolveVariablePath(condition, metadata);
+  const selectedPart = conditionValue ? truePart : falsePart;
+  if (selectedPart.startsWith('"') && selectedPart.endsWith('"') || // eslint-disable-next-line quotes
+  selectedPart.startsWith("'") && selectedPart.endsWith("'")) {
+    const unquotedValue = selectedPart.slice(1, -1);
+    if (enableFieldTracking) {
+      return `<span class="imported-value" data-field="${escapeHtmlAttribute(expression)}">${unquotedValue}</span>`;
     }
-    processDateReferencesInAST(tree, metadata, enableFieldTracking);
-    if (debug) {
-      console.log("✅ Date reference processing completed");
+    return unquotedValue;
+  }
+  const processedValue = processExpression(selectedPart, metadata);
+  if (enableFieldTracking) {
+    return `<span class="imported-value" data-field="${escapeHtmlAttribute(expression)}">${processedValue}</span>`;
+  }
+  return processedValue;
+}
+function findOperatorIndex(expression, operator, startIndex = 0) {
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = startIndex; i < expression.length; i++) {
+    const char = expression[i];
+    if (!inQuotes && (char === '"' || char === "'")) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (!inQuotes && char === operator) {
+      return i;
     }
-  };
-};
-
-const DEFAULT_OPTIONS = {
-  minUnderscores: 10,
-  addCssClass: true,
-  cssClassName: "signature-line",
-  debug: false
-};
-function sanitizeCssClassName(className) {
-  const validPattern = /^[a-zA-Z_][\w-]*$/;
-  if (!className || !validPattern.test(className)) {
-    console.warn(
-      `[signature-lines] Invalid CSS class name "${className}", using default "signature-line"`
-    );
-    return "signature-line";
   }
-  return className;
+  return -1;
 }
-const remarkSignatureLines = (options = {}) => {
-  const config = { ...DEFAULT_OPTIONS, ...options };
-  const safeCssClassName = sanitizeCssClassName(config.cssClassName);
-  return (tree) => {
-    if (config.debug) {
-      console.log("[signature-lines] Processing tree...");
+function processExpression(expression, metadata) {
+  if (expression.includes("+") && (expression.includes('"') || expression.includes("'"))) {
+    return evaluateStringConcatenation(expression, metadata);
+  }
+  if (expression.includes("*") || expression.includes("/") || expression.includes("+") || expression.includes("-")) {
+    return evaluateMathematicalExpression(expression, metadata);
+  }
+  const value = resolveVariablePath(expression, metadata);
+  return value !== void 0 ? String(value) : expression;
+}
+function evaluateStringConcatenation(expression, metadata) {
+  try {
+    let processedExpression = expression.trim();
+    const variablePattern = /\b[a-zA-Z_][a-zA-Z0-9_.]*\b/g;
+    const variables = /* @__PURE__ */ new Set();
+    let match;
+    let inQuotes = false;
+    let quoteChar = "";
+    for (let i = 0; i < expression.length; i++) {
+      const char = expression[i];
+      if (!inQuotes && (char === '"' || char === "'")) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (inQuotes && char === quoteChar) {
+        inQuotes = false;
+        quoteChar = "";
+      }
     }
-    visit(tree, "text", (node, index, parent) => {
-      if (index === void 0 || !parent) return;
-      const text = node.value;
-      const underscorePattern = new RegExp(`_{${config.minUnderscores},}`, "g");
-      if (!underscorePattern.test(text)) {
-        return;
+    while ((match = variablePattern.exec(expression)) !== null) {
+      const beforeMatch = expression.substring(0, match.index);
+      const openQuotes = (beforeMatch.match(/"/g) || []).length;
+      const openSingleQuotes = (beforeMatch.match(/'/g) || []).length;
+      if (openQuotes % 2 === 0 && openSingleQuotes % 2 === 0) {
+        variables.add(match[0]);
       }
-      if (config.debug) {
-        console.log("[signature-lines] Found signature line in text:", text);
+    }
+    for (const variable of variables) {
+      const value = resolveVariablePath(variable, metadata);
+      if (value !== void 0) {
+        const regex = new RegExp(`\\b${variable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
+        if (typeof value === "string") {
+          processedExpression = processedExpression.replace(regex, `"${value}"`);
+        } else {
+          processedExpression = processedExpression.replace(regex, String(value));
+        }
+      } else {
+        return expression;
       }
-      if (!config.addCssClass) {
-        return;
+    }
+    const result = new Function(`"use strict"; return (${processedExpression})`)();
+    return String(result);
+  } catch (error) {
+    return expression;
+  }
+}
+function evaluateMathematicalExpression(expression, metadata) {
+  try {
+    let processedExpression = expression;
+    const variablePattern = /[a-zA-Z_][a-zA-Z0-9_.]*(?![a-zA-Z0-9_.])/g;
+    const variables = /* @__PURE__ */ new Set();
+    let match;
+    while ((match = variablePattern.exec(expression)) !== null) {
+      variables.add(match[0]);
+    }
+    for (const variable of variables) {
+      const value = resolveVariablePath(variable, metadata);
+      if (value !== void 0 && !isNaN(Number(value))) {
+        const regex = new RegExp(`\\b${variable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
+        processedExpression = processedExpression.replace(regex, String(value));
+      } else {
+        return expression;
       }
-      const processedText = text.replace(underscorePattern, (match) => {
-        if (config.debug) {
-          console.log(`[signature-lines] Wrapping ${match.length} underscores`);
-        }
-        return `<span class="${safeCssClassName}">${match}</span>`;
-      });
-      const htmlNode = {
-        type: "html",
-        value: processedText
-      };
-      parent.children[index] = htmlNode;
-    });
-    if (config.debug) {
-      console.log("[signature-lines] Processing complete");
     }
-  };
-};
+    if (!/^[\d\s+\-*/().]+$/.test(processedExpression)) {
+      return expression;
+    }
+    const result = new Function(`"use strict"; return (${processedExpression})`)();
+    return typeof result === "number" && !isNaN(result) ? String(result) : expression;
+  } catch (error) {
+    return expression;
+  }
+}
+function resolveVariablePath(path, metadata, context) {
+  if (path === ".") {
+    return metadata["."];
+  }
+  const parts = path.split(".");
+  let current = metadata;
+  for (const part of parts) {
+    if (current && typeof current === "object" && Object.prototype.hasOwnProperty.call(current, part)) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function convertMarkdownListToHtml(content) {
+  const trimmedContent = content.trim();
+  if (trimmedContent.startsWith("- ")) {
+    const listItemContent = trimmedContent.substring(2).trim();
+    return `<li>${listItemContent}</li>`;
+  }
+  return content;
+}
+function evaluateCondition(condition, metadata) {
+  const value = resolveVariablePath(condition, metadata);
+  if (value === null || value === void 0) return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") return value.length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return Boolean(value);
+}
+function processTemplateContent(content, metadata, context, enableFieldTracking = true) {
+  let processedContent = processTemplateLoops(content, metadata, context, enableFieldTracking);
+  processedContent = processedContent.replace(/\{\{([^#/][^}]*)\}\}/g, (match, variable) => {
+    const trimmedVar = variable.trim();
+    const value = resolveVariablePath(trimmedVar, metadata);
+    if (value !== void 0) {
+      if (enableFieldTracking) {
+        const isEmptyValue = value === null || value === "" || typeof value === "string" && value.trim() === "";
+        const cssClass = isEmptyValue ? "legal-field missing-value" : "legal-field imported-value";
+        fieldTracker.trackField(trimmedVar, {
+          value,
+          originalValue: match,
+          hasLogic: false
+        });
+        return `<span class="${cssClass}" data-field="${escapeHtmlAttribute(trimmedVar)}">${String(value)}</span>`;
+      }
+      return String(value);
+    }
+    return match;
+  });
+  return processedContent;
+}
 
 var define_process_default = { env: { NODE_ENV: "production", DEBUG: false } };
 function exportMetadata(metadata, format, outputPath) {
@@ -22707,6 +22906,10 @@ function filterMetadataForExport(metadata) {
   return result;
 }
 
+function asMarkdown(content) {
+  return content;
+}
+
 const unsafeWithoutUnderscores = [
   { character: "	", after: "[\\r\\n]", inConstruct: "phrasing" },
   { character: "	", before: "[\\r\\n]", inConstruct: "phrasing" },
@@ -22848,6 +23051,7 @@ function escapeTemplateUnderscores(content) {
 }
 function createLegalMarkdownProcessor(metadata, options) {
   const processor = unified().use(remarkParse);
+  const pluginOrder = [];
   if (!options.noImports) {
     processor.use(remarkImports, {
       basePath: options.basePath || ".",
@@ -22932,6 +23136,42 @@ function createLegalMarkdownProcessor(metadata, options) {
     unsafe: unsafeWithoutUnderscores
     // Use filtered unsafe patterns without underscores
   });
+  if (!options.noImports) pluginOrder.push("remarkImports");
+  if (!options.noHeaders) pluginOrder.push("remarkLegalHeadersParser");
+  if (!options.noMixins) pluginOrder.push("remarkMixins");
+  if (!options.noClauses) pluginOrder.push("remarkClauses");
+  pluginOrder.push("remarkDates");
+  pluginOrder.push("remarkSignatureLines");
+  pluginOrder.push("remarkTemplateFields");
+  if (!options.disableCrossReferences && !options.noReferences) {
+    pluginOrder.push("remarkCrossReferences");
+  }
+  if (!options.noHeaders) pluginOrder.push("remarkHeaders");
+  if (options.debug || options.validatePluginOrder) {
+    try {
+      const validator = new PluginOrderValidator(GLOBAL_PLUGIN_REGISTRY);
+      const result = validator.validate(pluginOrder, {
+        throwOnError: false,
+        // Don't throw, just log warnings
+        logWarnings: options.debug || options.validatePluginOrder,
+        strictMode: false,
+        debug: options.debug
+      });
+      if (!result.valid && options.debug) {
+        console.warn("[LegalMarkdownProcessor] Plugin order validation warnings detected");
+        for (const error of result.errors) {
+          console.warn(`  - ${error.message}`);
+        }
+        if (result.suggestedOrder) {
+          console.warn("  Suggested order:", result.suggestedOrder.join(" → "));
+        }
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.warn("[LegalMarkdownProcessor] Plugin order validation failed:", error);
+      }
+    }
+  }
   return processor;
 }
 async function processLegalMarkdownWithRemark(content, options = {}) {
@@ -22979,7 +23219,7 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
         );
       }
       return {
-        content: contentWithEscapedTemplates,
+        content: asMarkdown(contentWithEscapedTemplates),
         metadata: { ...yamlMetadata, ...options.additionalMetadata },
         stats: {
           processingTime: Date.now() - startTime,
@@ -22992,7 +23232,7 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
     }
     if (options.yamlOnly) {
       return {
-        content: contentWithEscapedTemplates,
+        content: asMarkdown(contentWithEscapedTemplates),
         metadata: yamlMetadata,
         stats: {
           processingTime: Date.now() - startTime,
@@ -23007,7 +23247,7 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
       ...yamlMetadata,
       ...options.additionalMetadata
     };
-    const { parseForceCommands, applyForceCommands } = await import('./force-commands-parser-CkTMgF1y.js');
+    const { parseForceCommands, applyForceCommands } = await import('./force-commands-parser-DDda8v0G.js');
     let updatedOptions = { ...options };
     if (combinedMetadata.force_commands && typeof combinedMetadata.force_commands === "string") {
       const forceCommands = parseForceCommands(combinedMetadata.force_commands, combinedMetadata);
@@ -23087,8 +23327,8 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
     }
     const result = await processor.process(preprocessedContent);
     const processedContent = String(result);
-    const processedTree = result.history[0];
-    const importedMetadata = processedTree?._importedMetadata || {};
+    const processedTree = result.value;
+    const importedMetadata = result.history[0]?._importedMetadata || {};
     const finalMetadata = {
       ...importedMetadata,
       ...combinedMetadata
@@ -23136,8 +23376,10 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
       console.log(`📋 Fields tracked: ${fieldsTracked}`);
     }
     return {
-      content: processedContent,
+      content: asMarkdown(processedContent),
       metadata: finalMetadata,
+      ast: processedTree,
+      // Cached AST for Phase 3
       exportedFiles: exportedFiles.length > 0 ? exportedFiles : void 0,
       fieldReport,
       stats: {
@@ -23196,5 +23438,5 @@ if (typeof window !== "undefined" && window.DEBUG_LEGAL_MARKDOWN) {
   });
 }
 
-export { LegalMarkdown as L, processLegalMarkdown as a, processLegalMarkdownSync as b, logger as l, processMixins as p };
-//# sourceMappingURL=browser-modern-wM0F4Tg1.js.map
+export { LegalMarkdown as L, processLegalMarkdown as a, processLegalMarkdownSync as b, extensionHelpers as e, fieldTracker as f, logger as l, processTemplateLoops as p };
+//# sourceMappingURL=browser-modern-BP5EJrCS.js.map