legal-markdown-js 2.3.0 → 2.5.0

package/README.md

@@ -5,8 +5,8 @@
 > feature parity.
 
 Process markdown with YAML front matter, conditional clauses
-`[text]{condition}`, cross-references `|variable|`, imports `@import`, and
-generate professional PDFs ready to be shared.
+`[text]{condition}`, cross-references `|reference|`, mixins `{{variable}}`,
+imports `@import`, and generate professional PDFs ready to be shared.
 
 ![Legal Markdown JS Example](docs/legal-markdown-js-example.png)
 
@@ -60,16 +60,29 @@ legal-md document.md --html --css styles.css
 ### Programmatic Usage
 
 ```typescript
-import { processLegalMarkdown } from 'legal-markdown-js';
+import {
+  processLegalMarkdown,
+  processLegalMarkdownAsync,
+} from 'legal-markdown-js';
 
+// Synchronous processing (legacy)
 const result = processLegalMarkdown(content, {
   basePath: './documents',
   exportMetadata: true,
   exportFormat: 'json',
 });
 
-console.log(result.content);
-console.log(result.metadata);
+// Asynchronous processing with modern pipeline (recommended)
+const asyncResult = await processLegalMarkdownAsync(content, {
+  basePath: './documents',
+  exportMetadata: true,
+  exportFormat: 'json',
+  enableFieldTracking: true,
+});
+
+console.log(asyncResult.content);
+console.log(asyncResult.metadata);
+console.log(asyncResult.fieldReport); // Enhanced field tracking
 ```
 
 ## Key Features
@@ -84,8 +97,7 @@ All original Legal Markdown features are fully implemented:
   `lll.`)
 - **Optional Clauses**: Boolean, equality, and logical operations
   (`[text]{condition}`)
-- **Cross-References**: All reference types including special date handling
-  (`|reference|`)
+- **Cross-References**: Internal section references using (`|reference|`) syntax
 - **Partial Imports**: File inclusion with path resolution (`@import`)
 - **Metadata Export**: YAML and JSON export with custom paths
 
@@ -93,14 +105,60 @@ All original Legal Markdown features are fully implemented:
 
 Additional features available only in the Node.js version:
 
-- **Mixins System**: Template substitution with `{{variable}}` syntax
+- **Mixins System**: Template substitution and helpers with `{{variable}}`
+  syntax
+- **AST-Based Processing**: Modern AST-based mixin processing to prevent text
+  contamination (v2.4.0+)
+- **Pipeline Architecture**: Configurable step-based processing pipeline with
+  dependency management and performance monitoring (v2.4.0+)
 - **PDF Generation**: Professional PDF output with styling and field
   highlighting
 - **HTML Generation**: Custom HTML output with CSS support
-- **Template Loops**: Array iteration with `[#items]...[/items]` syntax
+- **Template Loops**: Array iteration with `{{#items}}...{{/items}}` syntax
 - **Helper Functions**: Date, number, and string formatting helpers
 - **Force Commands**: Document-driven configuration with embedded CLI options
 - **Batch Processing**: Multi-file processing with concurrency control
+- **Field Tracking**: Enhanced field tracking with proper categorization for
+  document review
+
+## Architecture & Performance
+
+### Modern Pipeline System (v2.4.0+)
+
+Legal Markdown JS features a completely rewritten processing pipeline that
+provides:
+
+- **Step-Based Architecture**: Configurable processing steps with dependency
+  management
+- **AST-Based Processing**: Modern AST parsing for mixin processing to prevent
+  text contamination
+- **Performance Monitoring**: Built-in step profiling and performance metrics
+- **Error Recovery**: Graceful fallback to legacy processing when needed
+- **Field Tracking**: Enhanced field tracking with proper status categorization
+
+#### Processing Order
+
+The new pipeline ensures correct processing order to prevent conflicts:
+
+1. **YAML Front Matter** - Parse document metadata
+2. **Import Processing** - Handle file imports and inclusions
+3. **Optional Clauses** - Process conditional text blocks
+4. **Cross-References** - Resolve internal document references
+5. **Template Loops** - Expand array iterations first
+6. **AST Mixin Processing** - Process variables and helpers (avoids loop
+   conflicts)
+7. **Header Processing** - Apply numbering and formatting
+8. **Field Tracking** - Apply highlighting and generate reports
+
+#### API Usage
+
+```typescript
+// Use the modern async API for best performance
+const result = await processLegalMarkdownAsync(content, options);
+
+// Automatic fallback to legacy processing if needed
+// No code changes required for existing applications
+```
 
 ## Documentation
 

package/dist/core/index.d.ts

@@ -14,6 +14,8 @@
  * - Mixin system for reusable content
  * - Date processing utilities
  * - Metadata export capabilities
+ * - Base processor interfaces for pipeline management
+ * - Core field tracking infrastructure
  *
  * @example
  * ```typescript
@@ -21,12 +23,21 @@
  *   parseYamlFrontMatter,
  *   processHeaders,
  *   processOptionalClauses,
- *   processCrossReferences
+ *   processCrossReferences,
+ *   BaseProcessor,
+ *   FieldState
  * } from './core';
  *
  * // Use core processors in a custom pipeline
  * const { content, metadata } = parseYamlFrontMatter(rawContent);
  * const processed = processHeaders(content, metadata);
+ *
+ * // Implement a custom processor
+ * class MyProcessor implements BaseProcessor {
+ *   name = 'my-processor';
+ *   isEnabled(options) { return true; }
+ *   process(content, metadata, options) { return content; }
+ * }
  * ```
  */
 export * from './parsers/yaml-parser';
@@ -34,7 +45,9 @@ export * from './processors/header-processor';
 export * from './processors/clause-processor';
 export * from './processors/reference-processor';
 export * from './processors/import-processor';
-export * from './processors/mixin-processor';
+export * from '../extensions/ast-mixin-processor';
 export * from './processors/date-processor';
 export * from './exporters/metadata-exporter';
+export * from './processors/base-processor';
+export * from './tracking/field-state';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,cAAc,uBAAuB,CAAC;AAGtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAG5C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC"}

package/dist/core/index.js

@@ -15,6 +15,8 @@
  * - Mixin system for reusable content
  * - Date processing utilities
  * - Metadata export capabilities
+ * - Base processor interfaces for pipeline management
+ * - Core field tracking infrastructure
  *
  * @example
  * ```typescript
@@ -22,12 +24,21 @@
  *   parseYamlFrontMatter,
  *   processHeaders,
  *   processOptionalClauses,
- *   processCrossReferences
+ *   processCrossReferences,
+ *   BaseProcessor,
+ *   FieldState
  * } from './core';
  *
  * // Use core processors in a custom pipeline
  * const { content, metadata } = parseYamlFrontMatter(rawContent);
  * const processed = processHeaders(content, metadata);
+ *
+ * // Implement a custom processor
+ * class MyProcessor implements BaseProcessor {
+ *   name = 'my-processor';
+ *   isEnabled(options) { return true; }
+ *   process(content, metadata, options) { return content; }
+ * }
  * ```
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -45,12 +56,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Core parsers
 __exportStar(require("./parsers/yaml-parser"), exports);
+// Core processors
 __exportStar(require("./processors/header-processor"), exports);
 __exportStar(require("./processors/clause-processor"), exports);
 __exportStar(require("./processors/reference-processor"), exports);
 __exportStar(require("./processors/import-processor"), exports);
-__exportStar(require("./processors/mixin-processor"), exports);
+__exportStar(require("../extensions/ast-mixin-processor"), exports);
 __exportStar(require("./processors/date-processor"), exports);
+// Core exporters
 __exportStar(require("./exporters/metadata-exporter"), exports);
+// Core infrastructure for pipeline management
+__exportStar(require("./processors/base-processor"), exports);
+__exportStar(require("./tracking/field-state"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;;;;;;;;;;;;;;AAEH,wDAAsC;AACtC,gEAA8C;AAC9C,gEAA8C;AAC9C,mEAAiD;AACjD,gEAA8C;AAC9C,+DAA6C;AAC7C,8DAA4C;AAC5C,gEAA8C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;;;;;;;;;;;;;;;;AAEH,eAAe;AACf,wDAAsC;AAEtC,kBAAkB;AAClB,gEAA8C;AAC9C,gEAA8C;AAC9C,mEAAiD;AACjD,gEAA8C;AAC9C,oEAAkD;AAClD,8DAA4C;AAE5C,iBAAiB;AACjB,gEAA8C;AAE9C,8CAA8C;AAC9C,8DAA4C;AAC5C,yDAAuC"}

package/dist/core/processors/base-processor.d.ts

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview Base Processor Interface for Legal Markdown Processing Pipeline
+ *
+ * This module defines the fundamental interface that all processors in the Legal Markdown
+ * pipeline must implement. It provides a standardized contract for processing steps,
+ * enabling the pipeline manager to orchestrate document processing in a consistent manner.
+ *
+ * Features:
+ * - Standardized processor interface
+ * - Enable/disable logic per processor
+ * - Consistent processing contract
+ * - Pipeline orchestration support
+ * - Backward compatibility with existing processors
+ *
+ * @example
+ * ```typescript
+ * import { BaseProcessor } from './base-processor';
+ *
+ * class MyCustomProcessor implements BaseProcessor {
+ *   name = 'my-custom-processor';
+ *
+ *   isEnabled(options: LegalMarkdownOptions): boolean {
+ *     return !options.noCustomProcessing;
+ *   }
+ *
+ *   process(content: string, metadata: Record<string, any>, options: any): string {
+ *     // Custom processing logic
+ *     return processedContent;
+ *   }
+ * }
+ * ```
+ */
+import { LegalMarkdownOptions } from '@types';
+/**
+ * Base interface that all processors in the Legal Markdown pipeline must implement
+ *
+ * This interface ensures consistency across all processing steps and enables
+ * the pipeline manager to coordinate document processing effectively.
+ *
+ * @interface BaseProcessor
+ * @example
+ * ```typescript
+ * class MixinProcessor implements BaseProcessor {
+ *   name = 'mixins';
+ *
+ *   isEnabled(options: LegalMarkdownOptions): boolean {
+ *     return !options.noMixins;
+ *   }
+ *
+ *   process(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string {
+ *     return processMixins(content, metadata, options);
+ *   }
+ * }
+ * ```
+ */
+export interface BaseProcessor {
+    /** Unique name identifier for this processor */
+    readonly name: string;
+    /**
+     * Determines whether this processor should be executed based on the provided options
+     *
+     * @param options - The Legal Markdown processing options
+     * @returns True if the processor should be executed, false otherwise
+     * @example
+     * ```typescript
+     * // Processor that runs unless explicitly disabled
+     * isEnabled(options: LegalMarkdownOptions): boolean {
+     *   return !options.noMixins;
+     * }
+     *
+     * // Processor that only runs when specific option is enabled
+     * isEnabled(options: LegalMarkdownOptions): boolean {
+     *   return options.enableAdvancedFeatures;
+     * }
+     * ```
+     */
+    isEnabled(options: LegalMarkdownOptions): boolean;
+    /**
+     * Processes the document content according to this processor's specific logic
+     *
+     * @param content - The document content to process
+     * @param metadata - The document metadata (YAML front matter, etc.)
+     * @param options - The Legal Markdown processing options
+     * @returns The processed content
+     * @throws {Error} When processing fails critically
+     * @example
+     * ```typescript
+     * process(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string {
+     *   if (!this.isEnabled(options)) {
+     *     return content; // Return unchanged if disabled
+     *   }
+     *
+     *   try {
+     *     return this.performProcessing(content, metadata, options);
+     *   } catch (error) {
+     *     console.warn(`Processor ${this.name} failed, returning original content:`, error);
+     *     return content; // Graceful fallback
+     *   }
+     * }
+     * ```
+     */
+    process(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string;
+}
+/**
+ * Abstract base class that provides common functionality for processors
+ *
+ * This class implements common patterns and provides utility methods that
+ * most processors will need, reducing boilerplate code.
+ *
+ * @abstract
+ * @class AbstractProcessor
+ * @implements {BaseProcessor}
+ * @example
+ * ```typescript
+ * class MyProcessor extends AbstractProcessor {
+ *   name = 'my-processor';
+ *
+ *   isEnabled(options: LegalMarkdownOptions): boolean {
+ *     return !options.noMyProcessor;
+ *   }
+ *
+ *   protected performProcessing(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string {
+ *     // Actual processing logic here
+ *     return processedContent;
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AbstractProcessor implements BaseProcessor {
+    abstract readonly name: string;
+    abstract isEnabled(options: LegalMarkdownOptions): boolean;
+    /**
+     * Template method that handles common processing patterns
+     *
+     * This method provides error handling, logging, and other common functionality,
+     * delegating the actual processing to the performProcessing method.
+     */
+    process(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string;
+    /**
+     * Abstract method where subclasses implement their specific processing logic
+     *
+     * @param content - The document content to process
+     * @param metadata - The document metadata
+     * @param options - The processing options
+     * @returns The processed content
+     * @protected
+     */
+    protected abstract performProcessing(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string;
+    /**
+     * Utility method to check if content has already been processed by another step
+     *
+     * This helps prevent double-processing and conflicts between processors.
+     *
+     * @param content - The content to check
+     * @returns True if content appears to have been processed (contains spans, etc.)
+     * @protected
+     */
+    protected hasBeenProcessed(content: string): boolean;
+    /**
+     * Utility method to log processing information in debug mode
+     *
+     * @param message - The message to log
+     * @param data - Optional data to include in the log
+     * @protected
+     */
+    protected debug(message: string, data?: any): void;
+}
+//# sourceMappingURL=base-processor.d.ts.map

package/dist/core/processors/base-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/base-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC;IAElD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAAC;CAChG;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8BAAsB,iBAAkB,YAAW,aAAa;IAC9D,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO;IAE1D;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,oBAAoB,GAAG,MAAM;IAa9F;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,OAAO,EAAE,oBAAoB,GAC5B,MAAM;IAET;;;;;;;;OAQG;IACH,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQpD;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;CAKnD"}

package/dist/core/processors/base-processor.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * @fileoverview Base Processor Interface for Legal Markdown Processing Pipeline
+ *
+ * This module defines the fundamental interface that all processors in the Legal Markdown
+ * pipeline must implement. It provides a standardized contract for processing steps,
+ * enabling the pipeline manager to orchestrate document processing in a consistent manner.
+ *
+ * Features:
+ * - Standardized processor interface
+ * - Enable/disable logic per processor
+ * - Consistent processing contract
+ * - Pipeline orchestration support
+ * - Backward compatibility with existing processors
+ *
+ * @example
+ * ```typescript
+ * import { BaseProcessor } from './base-processor';
+ *
+ * class MyCustomProcessor implements BaseProcessor {
+ *   name = 'my-custom-processor';
+ *
+ *   isEnabled(options: LegalMarkdownOptions): boolean {
+ *     return !options.noCustomProcessing;
+ *   }
+ *
+ *   process(content: string, metadata: Record<string, any>, options: any): string {
+ *     // Custom processing logic
+ *     return processedContent;
+ *   }
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractProcessor = void 0;
+/**
+ * Abstract base class that provides common functionality for processors
+ *
+ * This class implements common patterns and provides utility methods that
+ * most processors will need, reducing boilerplate code.
+ *
+ * @abstract
+ * @class AbstractProcessor
+ * @implements {BaseProcessor}
+ * @example
+ * ```typescript
+ * class MyProcessor extends AbstractProcessor {
+ *   name = 'my-processor';
+ *
+ *   isEnabled(options: LegalMarkdownOptions): boolean {
+ *     return !options.noMyProcessor;
+ *   }
+ *
+ *   protected performProcessing(content: string, metadata: Record<string, any>, options: LegalMarkdownOptions): string {
+ *     // Actual processing logic here
+ *     return processedContent;
+ *   }
+ * }
+ * ```
+ */
+class AbstractProcessor {
+    /**
+     * Template method that handles common processing patterns
+     *
+     * This method provides error handling, logging, and other common functionality,
+     * delegating the actual processing to the performProcessing method.
+     */
+    process(content, metadata, options) {
+        if (!this.isEnabled(options)) {
+            return content;
+        }
+        try {
+            return this.performProcessing(content, metadata, options);
+        }
+        catch (error) {
+            console.warn(`Processor '${this.name}' failed, returning original content:`, error);
+            return content;
+        }
+    }
+    /**
+     * Utility method to check if content has already been processed by another step
+     *
+     * This helps prevent double-processing and conflicts between processors.
+     *
+     * @param content - The content to check
+     * @returns True if content appears to have been processed (contains spans, etc.)
+     * @protected
+     */
+    hasBeenProcessed(content) {
+        return (content.includes('class="imported-value"') ||
+            content.includes('class="missing-value"') ||
+            content.includes('class="highlight"'));
+    }
+    /**
+     * Utility method to log processing information in debug mode
+     *
+     * @param message - The message to log
+     * @param data - Optional data to include in the log
+     * @protected
+     */
+    debug(message, data) {
+        if (process.env.NODE_ENV === 'development') {
+            console.log(`[${this.name.toUpperCase()}] ${message}`, data || '');
+        }
+    }
+}
+exports.AbstractProcessor = AbstractProcessor;
+//# sourceMappingURL=base-processor.js.map

package/dist/core/processors/base-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-processor.js","sourceRoot":"","sources":["../../../src/core/processors/base-processor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;;;AA6EH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAsB,iBAAiB;IAIrC;;;;;OAKG;IACH,OAAO,CAAC,OAAe,EAAE,QAA6B,EAAE,OAA6B;QACnF,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7B,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,IAAI,uCAAuC,EAAE,KAAK,CAAC,CAAC;YACpF,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAiBD;;;;;;;;OAQG;IACO,gBAAgB,CAAC,OAAe;QACxC,OAAO,CACL,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAC;YAC1C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAC;YACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CACtC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,OAAe,EAAE,IAAU;QACzC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,EAAE,CAAC;YAC3C,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;CACF;AAnED,8CAmEC"}

package/dist/core/processors/reference-processor.d.ts

@@ -1,115 +1,69 @@
 /**
  * @fileoverview Cross-Reference Processing Module for Legal Markdown Documents
  *
- * This module provides functionality to process cross-references in Legal Markdown
- * documents, replacing reference placeholders with actual values from metadata.
- * It supports various formatting options including date formatting, currency
- * formatting, and nested metadata access through dot notation.
+ * This module provides functionality to process internal cross-references in Legal Markdown
+ * documents, allowing sections to reference other sections by their keys.
+ * Based on the original Ruby Legal Markdown specification.
  *
  * Features:
- * - Cross-reference syntax: |reference_key|
- * - Date reference processing with @today support
- * - Automatic currency formatting for amount fields
- * - Nested metadata value access with dot notation
- * - Type-aware value formatting (dates, numbers, strings)
- * - Fallback to original reference if value not found
- * - Integration with date-processor for date handling
+ * - Internal cross-reference syntax: |reference_key|
+ * - Automatic section numbering and reference resolution
+ * - Reference capture from headers with |key| syntax
+ * - Section reference replacement throughout the document
+ * - Compatible with legal document numbering (l., ll., lll.)
  *
  * @example
  * ```typescript
  * import { processCrossReferences } from './reference-processor';
  *
  * const content = `
- * This agreement is between |client.name| and |provider.name|.
- * The total amount is |contract.amount| due on |contract.due_date|.
- * Document generated on |@today|.
- * `;
+ * l. **Definitions** |definitions|
+ *
+ * Terms defined in |definitions| apply throughout this agreement.
  *
- * const metadata = {
- *   client: { name: "Acme Corp" },
- *   provider: { name: "Service Ltd" },
- *   contract: {
- *     amount: 25000,
- *     due_date: new Date("2024-12-31")
- *   },
- *   payment_currency: "USD"
- * };
+ * l. **Payment Terms** |payment|
  *
- * const processed = processCrossReferences(content, metadata);
+ * As outlined in |payment|, payment is due within 30 days.
+ * Reference to |definitions| for term meanings.
+ * `;
+ *
+ * const processed = processCrossReferences(content, {});
  * console.log(processed);
  * // Output:
- * // This agreement is between Acme Corp and Service Ltd.
- * // The total amount is $25,000.00 due on 2024-12-31.
- * // Document generated on 2024-01-15.
+ * // Article 1. **Definitions**
+ * //
+ * // Terms defined in Article 1 apply throughout this agreement.
+ * //
+ * // Article 2. **Payment Terms**
+ * //
+ * // As outlined in Article 2, payment is due within 30 days.
+ * // Reference to Article 1 for term meanings.
  * ```
  */
 /**
- * Processes cross-references in a LegalMarkdown document
+ * Processes internal cross-references in a Legal Markdown document
  *
- * This is the main function that processes cross-references using the |reference_key|
- * syntax. It first processes date references, then handles regular cross-references
- * with automatic formatting based on value type and field names.
+ * This function implements a hybrid approach:
+ * 1. First tries to resolve |key| as internal section references (Ruby spec)
+ * 2. Falls back to metadata values for backward compatibility
  *
  * @param {string} content - The document content containing cross-references
- * @param {Record<string, any>} metadata - Document metadata with reference values
- * @returns {string} Processed content with references replaced by their values
+ * @param {Record<string, any>} metadata - Document metadata (used for level formatting and fallback)
+ * @returns {string} Processed content with internal references resolved
  * @example
  * ```typescript
- * // Basic reference processing
- * const content = "Payment due: |payment.amount| on |payment.date|";
- * const metadata = {
- *   payment: {
- *     amount: 1500,
- *     date: new Date("2024-03-15")
- *   },
- *   payment_currency: "EUR"
- * };
- *
- * const result = processCrossReferences(content, metadata);
- * // Output: "Payment due: €1,500.00 on 2024-03-15"
+ * const content = `
+ * l. **Contract Terms** |terms|
  *
- * // Nested reference access
- * const content2 = "Contact: |client.contact.email| (|client.contact.phone|)";
- * const metadata2 = {
- *   client: {
- *     contact: {
- *       email: "info@client.com",
- *       phone: "+1-555-0123"
- *     }
- *   }
- * };
+ * As specified in |terms|, this agreement is binding.
+ * Reference to |client_name| from metadata.
+ * `;
  *
- * const result2 = processCrossReferences(content2, metadata2);
- * // Output: "Contact: info@client.com (+1-555-0123)"
+ * const metadata = { client_name: "ACME Corp" };
+ * const result = processCrossReferences(content, metadata);
+ * // |terms| -> "Article 1." (internal reference)
+ * // |client_name| -> "ACME Corp" (metadata fallback)
  * ```
  */
 export declare function processCrossReferences(content: string, metadata: Record<string, any>): string;
-/**
- * Processes special reference formats like dates and currency amounts
- *
- * Applies appropriate formatting to reference values based on their type and
- * optional format specifiers. Handles dates, currency amounts, and falls back
- * to string conversion for other types.
- *
- * @param {any} value - The reference value to format
- * @param {string} [format] - Optional format specifier (e.g., "currency:USD:en-US")
- * @returns {string} Formatted value as string
- * @example
- * ```typescript
- * // Date formatting
- * const date = new Date("2024-03-15");
- * console.log(formatReferenceValue(date));           // "2024-03-15"
- * console.log(formatReferenceValue(date, "long"));   // "March 15, 2024"
- * console.log(formatReferenceValue(date, "short"));  // "3/15/2024"
- *
- * // Currency formatting
- * console.log(formatReferenceValue(1500, "currency:USD"));       // "$1,500.00"
- * console.log(formatReferenceValue(1500, "currency:EUR:de-DE")); // "1.500,00 €"
- *
- * // Default string conversion
- * console.log(formatReferenceValue("Hello World"));  // "Hello World"
- * console.log(formatReferenceValue(12345));          // "12345"
- * ```
- */
-export declare function formatReferenceValue(value: any, format?: string): string;
 //# sourceMappingURL=reference-processor.d.ts.map

package/dist/core/processors/reference-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/reference-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CA4B7F;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBxE"}
+{"version":3,"file":"reference-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/reference-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAWH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAM7F"}