legal-markdown-js 3.4.0 → 3.4.2

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

@@ -16229,10 +16229,11 @@ function extractTemplateFields(text, patterns) {
       if (isInsideLoopOrConditional(text, match.index)) {
         continue;
       }
+      const unescapedExpression = trimmedExpression.replace(/\\_/g, "_");
       fields.push({
         pattern: fullMatch,
-        fieldName: trimmedExpression,
-        expression: trimmedExpression,
+        fieldName: unescapedExpression,
+        expression: unescapedExpression,
         startIndex: match.index,
         endIndex: match.index + fullMatch.length
       });
@@ -17247,7 +17248,7 @@ function evaluateCondition$1(condition, metadata) {
   if (!sanitizedCondition) {
     return false;
   }
-  return evaluateSimpleCondition(sanitizedCondition, metadata);
+  return evaluateSimpleCondition$1(sanitizedCondition, metadata);
 }
 function sanitizeCondition(condition) {
   if (/<[^>]*>/.test(condition)) {
@@ -17269,26 +17270,26 @@ function sanitizeCondition(condition) {
   }
   return condition;
 }
-function evaluateSimpleCondition(condition, metadata) {
+function evaluateSimpleCondition$1(condition, metadata) {
   if (condition.includes("&&") || condition.includes("||")) {
-    return evaluateBooleanExpression(condition, metadata);
+    return evaluateBooleanExpression$1(condition, metadata);
   }
   if (condition.includes("==") || condition.includes("!=") || condition.includes(">") || condition.includes("<")) {
-    return evaluateComparisonExpression(condition, metadata);
+    return evaluateComparisonExpression$1(condition, metadata);
   }
   if (condition.includes(".")) {
     return evaluateNestedVariable(condition, metadata);
   }
   const value = metadata[condition.trim()];
-  return isTruthy(value);
+  return isTruthy$1(value);
 }
-function evaluateBooleanExpression(condition, metadata) {
+function evaluateBooleanExpression$1(condition, metadata) {
   const orParts = condition.split("||");
   for (const orPart of orParts) {
     const andParts = orPart.split("&&");
     let allAndTrue = true;
     for (const andPart of andParts) {
-      if (!evaluateSimpleCondition(andPart.trim(), metadata)) {
+      if (!evaluateSimpleCondition$1(andPart.trim(), metadata)) {
         allAndTrue = false;
         break;
       }
@@ -17299,7 +17300,7 @@ function evaluateBooleanExpression(condition, metadata) {
   }
   return false;
 }
-function evaluateComparisonExpression(condition, metadata) {
+function evaluateComparisonExpression$1(condition, metadata) {
   let operator = "";
   let leftSide = "";
   let rightSide = "";
@@ -17346,7 +17347,7 @@ function evaluateComparisonExpression(condition, metadata) {
 }
 function evaluateNestedVariable(condition, metadata) {
   const value = getNestedValue$1(metadata, condition.trim());
-  return isTruthy(value);
+  return isTruthy$1(value);
 }
 function getVariableValue(variable, metadata) {
   if (variable.includes(".")) {
@@ -17370,7 +17371,7 @@ function parseValue(value, metadata) {
   if (value === "false") return false;
   return getVariableValue(value, metadata);
 }
-function isTruthy(value) {
+function isTruthy$1(value) {
   if (value === null || value === void 0) return false;
   if (typeof value === "boolean") return value;
   if (typeof value === "number") return value !== 0;
@@ -20694,6 +20695,45 @@ function formatDateForYaml(date, format) {
   }
 }
 
+const NUMERIC_TYPED_ARRAY_TYPES = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+];
+function isBuffer(value) {
+  return typeof Buffer !== "undefined" && value instanceof Buffer;
+}
+function isBigIntTypedArray(value) {
+  if (typeof BigInt64Array !== "undefined" && value instanceof BigInt64Array) {
+    return true;
+  }
+  if (typeof BigUint64Array !== "undefined" && value instanceof BigUint64Array) {
+    return true;
+  }
+  return false;
+}
+function isTypedArray(value) {
+  return NUMERIC_TYPED_ARRAY_TYPES.some((Type) => value instanceof Type) || isBigIntTypedArray(value);
+}
+function isAtomicValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value !== "object") return true;
+  if (Array.isArray(value)) return true;
+  if (value instanceof Date) return true;
+  if (value instanceof RegExp) return true;
+  if (value instanceof Error) return true;
+  if (isBuffer(value)) return true;
+  if (value instanceof Set || value instanceof WeakSet) return true;
+  if (value instanceof Map || value instanceof WeakMap) return true;
+  if (isTypedArray(value)) return true;
+  return false;
+}
 function flattenObject(obj, prefix = "", visited = /* @__PURE__ */ new WeakSet(), startTime = Date.now(), timeoutMs = 5e3) {
   if (Date.now() - startTime > timeoutMs) {
     const message = `Object flattening timed out after ${timeoutMs}ms. This may indicate a complex nested structure or circular references.`;
@@ -20703,7 +20743,7 @@ function flattenObject(obj, prefix = "", visited = /* @__PURE__ */ new WeakSet()
     return {};
   }
   const flattened = {};
-  if (typeof obj !== "object" || Array.isArray(obj)) {
+  if (isAtomicValue(obj)) {
     if (prefix) {
       flattened[prefix] = obj;
     }
@@ -20719,14 +20759,10 @@ function flattenObject(obj, prefix = "", visited = /* @__PURE__ */ new WeakSet()
   visited.add(obj);
   for (const [key, value] of Object.entries(obj)) {
     const newKey = prefix ? `${prefix}.${key}` : key;
-    if (value === null || value === void 0) {
+    if (isAtomicValue(value)) {
       flattened[newKey] = value;
-    } else if (Array.isArray(value)) {
-      flattened[newKey] = value;
-    } else if (typeof value === "object") {
-      Object.assign(flattened, flattenObject(value, newKey, visited, startTime, timeoutMs));
     } else {
-      flattened[newKey] = value;
+      Object.assign(flattened, flattenObject(value, newKey, visited, startTime, timeoutMs));
     }
   }
   visited.delete(obj);
@@ -20948,8 +20984,12 @@ function validateMergeCompatibility(current, imported, key) {
       // Can parse strings as numbers
       ["boolean", "string"],
       // Can convert boolean to string
-      ["string", "boolean"]
+      ["string", "boolean"],
       // Can parse strings as boolean
+      ["date", "string"],
+      // YAML can serialize Date as string
+      ["string", "date"]
+      // String can represent a date
     ];
     const isCompatible = compatibleCombinations.some(
       ([type1, type2]) => currentType === type1 && importedType === type2 || currentType === type2 && importedType === type1
@@ -20968,6 +21008,14 @@ function getValueType(value) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
   if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Error) return "error";
+  if (isBuffer(value)) return "buffer";
+  if (value instanceof Set || value instanceof WeakSet) return "set";
+  if (value instanceof Map || value instanceof WeakMap) return "map";
+  if (NUMERIC_TYPED_ARRAY_TYPES.some((Type) => value instanceof Type)) return "typedarray";
+  if (isBigIntTypedArray(value)) return "typedarray";
   return typeof value;
 }
 function mergeSequentially(initial, imports, options = {}) {
@@ -21050,6 +21098,15 @@ function checkNestedConflicts(key, importedValue, currentFlat, logOperations) {
   return { hasConflict: false, conflictedField: "" };
 }
 
+var ProcessingPhase = /* @__PURE__ */ ((ProcessingPhase2) => {
+  ProcessingPhase2[ProcessingPhase2["CONTENT_LOADING"] = 1] = "CONTENT_LOADING";
+  ProcessingPhase2[ProcessingPhase2["VARIABLE_EXPANSION"] = 2] = "VARIABLE_EXPANSION";
+  ProcessingPhase2[ProcessingPhase2["CONDITIONAL_EVAL"] = 3] = "CONDITIONAL_EVAL";
+  ProcessingPhase2[ProcessingPhase2["STRUCTURE_PARSING"] = 4] = "STRUCTURE_PARSING";
+  ProcessingPhase2[ProcessingPhase2["POST_PROCESSING"] = 5] = "POST_PROCESSING";
+  return ProcessingPhase2;
+})(ProcessingPhase || {});
+
 const remarkImports = (options) => {
   const {
     basePath = ".",
@@ -21403,6 +21460,8 @@ async function expandMixinsInAST(nodes, metadata) {
   }
   return processedNodes;
 }
+({
+  phase: ProcessingPhase.CONTENT_LOADING});
 
 const LEGAL_HEADER_PATTERN = /^(l{1,9})\.\s+(.+)$/;
 function getHeadingLevel(pattern) {
@@ -21478,7 +21537,98 @@ const remarkLegalHeadersParser = (options = {}) => {
     const nodesToReplace = [];
     visit(tree, "paragraph", (node, index, parent) => {
       if (parent && typeof index === "number") {
-        if (node.children.length === 1 && node.children[0].type === "text") {
+        if (node.children.length === 1 && node.children[0].type === "html") {
+          const htmlNode = node.children[0];
+          const htmlValue = htmlNode.value || "";
+          if (htmlValue.includes("\n")) {
+            const lines = htmlValue.split("\n");
+            const hasLegalHeaders = lines.some((line) => /^(l{1,9})\.\s+/.test(line));
+            if (hasLegalHeaders) {
+              const newNodes = [];
+              const nonHeaderLines = [];
+              for (const line of lines) {
+                const match = line.match(/^(l{1,9})\.\s+(.*)$/);
+                if (match) {
+                  if (nonHeaderLines.length > 0) {
+                    newNodes.push({
+                      type: "paragraph",
+                      children: [
+                        {
+                          type: "html",
+                          value: nonHeaderLines.join("\n")
+                        }
+                      ]
+                    });
+                    nonHeaderLines.length = 0;
+                  }
+                  const [, levelPattern, remainingHtml] = match;
+                  const level = getHeadingLevel(levelPattern);
+                  if (debug) {
+                    console.log(
+                      `🔄 [remarkLegalHeadersParser] Converting HTML legal header (multiline) to level ${level} heading`
+                    );
+                  }
+                  const headingNode = {
+                    type: "heading",
+                    depth: level,
+                    children: [
+                      {
+                        type: "html",
+                        value: remainingHtml.trim()
+                      }
+                    ]
+                  };
+                  headingNode.data = { isLegalHeader: true };
+                  newNodes.push(headingNode);
+                  convertedCount++;
+                } else {
+                  nonHeaderLines.push(line);
+                }
+              }
+              if (nonHeaderLines.length > 0) {
+                newNodes.push({
+                  type: "paragraph",
+                  children: [
+                    {
+                      type: "html",
+                      value: nonHeaderLines.join("\n")
+                    }
+                  ]
+                });
+              }
+              if (newNodes.length > 0) {
+                nodesToReplace.push({ parent, index, newNodes });
+              }
+            }
+          } else {
+            const match = htmlValue.match(/^(l{1,9})\.\s+(.*)$/);
+            if (match) {
+              const [, levelPattern, remainingHtml] = match;
+              const level = getHeadingLevel(levelPattern);
+              if (debug) {
+                console.log(
+                  `🔄 [remarkLegalHeadersParser] Converting HTML legal header to level ${level} heading`
+                );
+              }
+              const heading = {
+                type: "heading",
+                depth: level,
+                children: [
+                  {
+                    type: "html",
+                    value: remainingHtml.trim()
+                  }
+                ]
+              };
+              heading.data = {
+                isLegalHeader: true,
+                hProperties: {}
+              };
+              nodesToReplace.push({ parent, index, newNodes: [heading] });
+              convertedCount++;
+            }
+          }
+        } else 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));
@@ -21645,6 +21795,25 @@ const remarkLegalHeadersParser = (options = {}) => {
 };
 function parseMarkdownInlineFormatting(text) {
   const children = [];
+  const templateFieldRanges = [];
+  const templateFieldRegex = /\{\{[^}]+\}\}/g;
+  let templateMatch;
+  while ((templateMatch = templateFieldRegex.exec(text)) !== null) {
+    templateFieldRanges.push({
+      start: templateMatch.index,
+      end: templateMatch.index + templateMatch[0].length
+    });
+  }
+  const isInsideTemplateField = (start, end) => {
+    return templateFieldRanges.some(
+      (range) => (
+        // Match starts inside range
+        start >= range.start && start < range.end || // Match ends inside range
+        end > range.start && end <= range.end || // Match completely encompasses range
+        start <= range.start && end >= range.end
+      )
+    );
+  };
   const patterns = [
     { regex: /\[([^\]]+)\]\([^)]+\)/g, type: "link" },
     // [text](url) - extract just the text
@@ -21663,9 +21832,14 @@ function parseMarkdownInlineFormatting(text) {
   for (const pattern of patterns) {
     let match;
     while ((match = pattern.regex.exec(text)) !== null) {
+      const matchStart = match.index;
+      const matchEnd = match.index + match[0].length;
+      if (isInsideTemplateField(matchStart, matchEnd)) {
+        continue;
+      }
       allMatches.push({
-        start: match.index,
-        end: match.index + match[0].length,
+        start: matchStart,
+        end: matchEnd,
         type: pattern.type,
         content: match[1]
       });
@@ -22035,6 +22209,8 @@ class PluginOrderValidator {
     }
     const circularErrors = this.detectCircularDependencies(pluginNames);
     errors.push(...circularErrors);
+    const capabilityErrors = this.validateCapabilities(pluginNames, { debug });
+    errors.push(...capabilityErrors);
     if (logWarnings && warnings.length > 0) {
       for (const warning of warnings) {
         console.warn(`[PluginOrderValidator] WARNING: ${warning.message}`);
@@ -22195,6 +22371,55 @@ Suggested order: ${suggestedOrder.join(" → ")}` : ""}`
   registerPlugin(metadata) {
     this.registry.set(metadata.name, metadata);
   }
+  /**
+   * Validate that all required capabilities are provided
+   *
+   * Checks that for each plugin's requiresCapabilities, there is at least
+   * one earlier plugin in the execution order that provides that capability.
+   *
+   * @param pluginNames - List of plugin names in execution order
+   * @param options - Validation options
+   * @returns Array of capability validation errors
+   */
+  validateCapabilities(pluginNames, options = {}) {
+    const errors = [];
+    const providedCapabilities = /* @__PURE__ */ new Set();
+    for (const pluginName of pluginNames) {
+      const metadata = this.registry.get(pluginName);
+      if (!metadata) continue;
+      if (metadata.requiresCapabilities) {
+        for (const requiredCap of metadata.requiresCapabilities) {
+          if (!providedCapabilities.has(requiredCap)) {
+            errors.push({
+              type: "capability-missing",
+              plugin: pluginName,
+              message: `Plugin "${pluginName}" requires capability "${requiredCap}" but no earlier plugin provides it`
+            });
+          }
+        }
+      }
+      if (metadata.requiresPhases && metadata.phase) {
+        for (const requiredPhase of metadata.requiresPhases) {
+          if (requiredPhase >= metadata.phase) {
+            errors.push({
+              type: "phase-dependency",
+              plugin: pluginName,
+              message: `Plugin "${pluginName}" (Phase ${metadata.phase}) requires Phase ${requiredPhase} which runs at the same time or later`
+            });
+          }
+        }
+      }
+      if (metadata.capabilities) {
+        for (const cap of metadata.capabilities) {
+          providedCapabilities.add(cap);
+          if (options.debug) {
+            console.log(`[PluginOrderValidator] Plugin "${pluginName}" provides: ${cap}`);
+          }
+        }
+      }
+    }
+    return errors;
+  }
 }
 function createPluginRegistry(metadataList) {
   const registry = /* @__PURE__ */ new Map();
@@ -22205,96 +22430,124 @@ function createPluginRegistry(metadataList) {
 }
 
 const PLUGIN_METADATA_LIST = [
-  // Phase 1: Import Processing
+  // ========== PHASE 1: CONTENT LOADING ==========
   {
     name: "remarkImports",
+    phase: ProcessingPhase.CONTENT_LOADING,
     description: "Process @import directives and insert content as AST nodes",
-    runBefore: [
-      "remarkTemplateFields",
-      "remarkLegalHeadersParser",
-      "remarkFieldTracking",
-      "remarkMixins"
-    ],
+    capabilities: ["content:imported", "metadata:merged"],
+    runBefore: ["remarkLegalHeadersParser", "remarkMixins"],
     required: false,
     version: "2.0.0"
     // Version 2.0 uses AST-based insertion
   },
-  // Phase 2: Mixin and Field Processing
+  // ========== PHASE 2: VARIABLE EXPANSION ==========
   {
     name: "remarkMixins",
-    description: "Process mixin definitions and expansions",
-    runAfter: ["remarkImports"],
+    phase: ProcessingPhase.VARIABLE_EXPANSION,
+    description: "Expand mixin definitions ({{variable}} patterns)",
+    requiresPhases: [ProcessingPhase.CONTENT_LOADING],
+    requiresCapabilities: ["metadata:merged"],
+    capabilities: ["mixins:expanded"],
     runBefore: ["remarkTemplateFields"],
     required: false
   },
   {
     name: "remarkTemplateFields",
+    phase: ProcessingPhase.VARIABLE_EXPANSION,
     description: "Process {{field}} template patterns and resolve values",
-    runAfter: ["remarkImports", "remarkMixins"],
-    runBefore: ["remarkFieldTracking"],
+    runAfter: ["remarkMixins"],
+    capabilities: ["fields:expanded", "variables:resolved"],
     required: true
   },
-  // Phase 3: Header Processing
+  // ========== PHASE 3: CONDITIONAL EVALUATION ==========
   {
-    name: "remarkLegalHeadersParser",
-    description: "Parse legal header markers (l., ll., lll.) into structured headers",
-    runAfter: ["remarkImports"],
-    runBefore: ["remarkHeaders"],
+    name: "processTemplateLoops",
+    phase: ProcessingPhase.CONDITIONAL_EVAL,
+    description: "Evaluate {{#if}}, {{#unless}}, {{#each}} conditionals",
+    requiresPhases: [ProcessingPhase.VARIABLE_EXPANSION],
+    requiresCapabilities: ["variables:resolved"],
+    capabilities: ["conditionals:evaluated"],
     required: true
   },
   {
-    name: "remarkHeaders",
-    description: "Process headers and add CSS classes (legal-header-level-X)",
-    runAfter: ["remarkLegalHeadersParser"],
-    required: true
+    name: "remarkClauses",
+    phase: ProcessingPhase.CONDITIONAL_EVAL,
+    description: "Process conditional clauses",
+    capabilities: ["clauses:processed"],
+    required: false
   },
-  // Phase 4: Field Tracking
+  // ========== PHASE 4: STRUCTURE PARSING ==========
   {
-    name: "remarkFieldTracking",
-    description: "Track template fields for highlighting and analysis",
-    runAfter: ["remarkTemplateFields"],
-    required: false
+    name: "remarkLegalHeadersParser",
+    phase: ProcessingPhase.STRUCTURE_PARSING,
+    description: "Parse legal header markers (l., ll., lll.) into structured headers",
+    requiresPhases: [ProcessingPhase.CONTENT_LOADING],
+    runBefore: ["remarkHeaders", "remarkCrossReferences"],
+    capabilities: ["headers:parsed"],
+    required: true
   },
-  // Phase 5: Cross-References and Clauses
   {
     name: "remarkCrossReferences",
+    phase: ProcessingPhase.STRUCTURE_PARSING,
     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
+    runBefore: ["remarkHeaders"],
+    requiresCapabilities: ["headers:parsed"],
+    capabilities: ["crossrefs:resolved"],
     required: false
   },
   {
     name: "remarkCrossReferencesAst",
+    phase: ProcessingPhase.STRUCTURE_PARSING,
     description: "AST-based cross-reference processing (alternative to remarkCrossReferences)",
     runAfter: ["remarkHeaders", "remarkLegalHeadersParser"],
+    requiresCapabilities: ["headers:parsed"],
+    capabilities: ["crossrefs:resolved"],
     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
+    name: "remarkHeaders",
+    phase: ProcessingPhase.STRUCTURE_PARSING,
+    description: "Number headers and add CSS classes",
+    // Note: remarkLegalHeadersParser.runBefore already declares the parser→headers dependency,
+    // so we don't need to duplicate it here with runAfter: ['remarkLegalHeadersParser'].
+    // Declaring dependencies from both sides causes double in-degree increments in topological sort.
+    runAfter: ["remarkCrossReferences"],
+    requiresCapabilities: ["headers:parsed"],
+    capabilities: ["headers:numbered"],
+    required: true
   },
-  // Phase 6: Date Processing
+  // ========== PHASE 5: POST-PROCESSING ==========
   {
     name: "remarkDates",
+    phase: ProcessingPhase.POST_PROCESSING,
     description: "Process date fields and formatting",
-    // Note: Can run before or after remarkTemplateFields depending on use case
+    capabilities: ["dates:formatted"],
     required: false
   },
-  // Phase 7: Signature Lines
   {
     name: "remarkSignatureLines",
+    phase: ProcessingPhase.POST_PROCESSING,
     description: "Process signature line markers",
+    capabilities: ["signatures:processed"],
+    required: false
+  },
+  {
+    name: "remarkFieldTracking",
+    phase: ProcessingPhase.POST_PROCESSING,
+    description: "Track template fields for highlighting and analysis",
+    requiresPhases: [ProcessingPhase.VARIABLE_EXPANSION],
+    requiresCapabilities: ["fields:expanded"],
+    capabilities: ["tracking:enabled"],
     required: false
   },
   // Utility Plugins
   {
     name: "remarkDebugAst",
+    phase: ProcessingPhase.POST_PROCESSING,
     description: "Debug plugin for visualizing AST structure",
     required: false
   }
@@ -22808,7 +23061,103 @@ function convertMarkdownListToHtml(content) {
   return content;
 }
 function evaluateCondition(condition, metadata) {
+  if (condition.includes("&&") || condition.includes("||")) {
+    return evaluateBooleanExpression(condition, metadata);
+  }
+  if (condition.includes("==") || condition.includes("!=") || condition.includes(">=") || condition.includes("<=") || condition.includes(">") || condition.includes("<")) {
+    return evaluateComparisonExpression(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 evaluateBooleanExpression(condition, metadata) {
+  const orParts = condition.split("||");
+  for (const orPart of orParts) {
+    const andParts = orPart.split("&&");
+    let allAndTrue = true;
+    for (const andPart of andParts) {
+      if (!evaluateSimpleCondition(andPart.trim(), metadata)) {
+        allAndTrue = false;
+        break;
+      }
+    }
+    if (allAndTrue) {
+      return true;
+    }
+  }
+  return false;
+}
+function evaluateSimpleCondition(condition, metadata) {
+  if (condition.includes("==") || condition.includes("!=") || condition.includes(">=") || condition.includes("<=") || condition.includes(">") || condition.includes("<")) {
+    return evaluateComparisonExpression(condition, metadata);
+  }
   const value = resolveVariablePath(condition, metadata);
+  return isTruthy(value);
+}
+function evaluateComparisonExpression(condition, metadata) {
+  let operator = "";
+  let leftSide = "";
+  let rightSide = "";
+  if (condition.includes("==")) {
+    [leftSide, rightSide] = condition.split("==");
+    operator = "==";
+  } else if (condition.includes("!=")) {
+    [leftSide, rightSide] = condition.split("!=");
+    operator = "!=";
+  } else if (condition.includes(">=")) {
+    [leftSide, rightSide] = condition.split(">=");
+    operator = ">=";
+  } else if (condition.includes("<=")) {
+    [leftSide, rightSide] = condition.split("<=");
+    operator = "<=";
+  } else if (condition.includes(">")) {
+    [leftSide, rightSide] = condition.split(">");
+    operator = ">";
+  } else if (condition.includes("<")) {
+    [leftSide, rightSide] = condition.split("<");
+    operator = "<";
+  }
+  if (!operator || !leftSide || !rightSide) {
+    return false;
+  }
+  const leftValue = resolveVariablePath(leftSide.trim(), metadata);
+  const rightValue = parseComparisonValue(rightSide.trim(), metadata);
+  switch (operator) {
+    case "==":
+      return leftValue == rightValue;
+    case "!=":
+      return leftValue != rightValue;
+    case ">":
+      return Number(leftValue) > Number(rightValue);
+    case "<":
+      return Number(leftValue) < Number(rightValue);
+    case ">=":
+      return Number(leftValue) >= Number(rightValue);
+    case "<=":
+      return Number(leftValue) <= Number(rightValue);
+    default:
+      return false;
+  }
+}
+function parseComparisonValue(value, metadata) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (/^\d+(\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  return resolveVariablePath(value, metadata);
+}
+function isTruthy(value) {
   if (value === null || value === void 0) return false;
   if (typeof value === "boolean") return value;
   if (typeof value === "number") return value !== 0;
@@ -23045,6 +23394,12 @@ const unsafeWithoutUnderscores = [
 ];
 function escapeTemplateUnderscores(content) {
   return content.replace(/\{\{([^}]+)\}\}/g, (match, inner) => {
+    const trimmed = inner.trim();
+    if (trimmed.startsWith("#") || // {{#if}}, {{#each}}, etc.
+    trimmed.startsWith("/") || // {{/if}}, {{/each}}, etc.
+    trimmed === "else") {
+      return match;
+    }
     const escaped = inner.replace(/_/g, "\\_");
     return `{{${escaped}}}`;
   });
@@ -23247,7 +23602,7 @@ async function processLegalMarkdownWithRemark(content, options = {}) {
       ...yamlMetadata,
       ...options.additionalMetadata
     };
-    const { parseForceCommands, applyForceCommands } = await import('./force-commands-parser-DDda8v0G.js');
+    const { parseForceCommands, applyForceCommands } = await import('./force-commands-parser-C5oEpEj4.js');
     let updatedOptions = { ...options };
     if (combinedMetadata.force_commands && typeof combinedMetadata.force_commands === "string") {
       const forceCommands = parseForceCommands(combinedMetadata.force_commands, combinedMetadata);
@@ -23439,4 +23794,4 @@ if (typeof window !== "undefined" && window.DEBUG_LEGAL_MARKDOWN) {
 }
 
 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
+//# sourceMappingURL=browser-modern-CeecamQe.js.map