legal-markdown-js 2.3.0 → 2.4.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)
 
@@ -84,8 +84,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,7 +92,8 @@ 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
 - **PDF Generation**: Professional PDF output with styling and field
   highlighting
 - **HTML Generation**: Custom HTML output with CSS support

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"}

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

@@ -2,144 +2,194 @@
 /**
  * @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.
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processCrossReferences = processCrossReferences;
-exports.formatReferenceValue = formatReferenceValue;
-const date_processor_1 = require("./date-processor");
 /**
- * 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)
  * ```
  */
 function processCrossReferences(content, metadata) {
-    // First process date references (@today)
-    const processedContent = (0, date_processor_1.processDateReferences)(content, metadata);
-    // Then process regular cross-references
-    // Format: |reference_key|
-    const referencePattern = /\|(.*?)\|/g;
-    return processedContent.replace(referencePattern, (match, key) => {
-        // Get the reference value from metadata
-        const value = getNestedValue(metadata, key.trim());
-        if (value === undefined) {
-            return match;
-        }
-        // Format value based on type
-        if (value instanceof Date) {
-            return formatDate(value);
-        }
-        else if (typeof value === 'number' && key.includes('amount')) {
-            // Format currency if key contains 'amount'
-            const currency = metadata.payment_currency || 'USD';
-            return formatCurrency(value, `currency:${currency}`);
-        }
-        // Default string conversion
-        return String(value);
-    });
+    // First, extract all cross-reference definitions from headers
+    const crossReferences = extractCrossReferences(content, metadata);
+    // Then replace all cross-reference usage with section numbers or metadata
+    return replaceCrossReferences(content, crossReferences, metadata);
 }
 /**
- * Gets a potentially nested value from an object
+ * Extracts cross-reference definitions from headers in the document
  *
- * Traverses an object using dot notation to access nested properties safely.
- * Returns undefined if any part of the path doesn't exist, preventing errors
- * when accessing deeply nested properties.
+ * Scans the document for headers containing |key| syntax and captures
+ * their section numbers after header processing. This creates a mapping
+ * of reference keys to their section identifiers.
  *
  * @private
- * @param {Record<string, any>} obj - Object to extract value from
- * @param {string} path - Dot-separated path to the value (e.g., "user.profile.name")
- * @returns {any} The value at the specified path, or undefined if not found
- * @example
- * ```typescript
- * const obj = {
- *   contract: {
- *     parties: {
- *       client: { name: "Acme Corp", id: 12345 },
- *       provider: { name: "Service Ltd" }
- *     },
- *     terms: { duration: 12 }
- *   }
- * };
+ * @param {string} content - Document content to scan for cross-references
+ * @param {Record<string, any>} metadata - Metadata for level formatting
+ * @returns {CrossReference[]} Array of cross-reference mappings
+ */
+function extractCrossReferences(content, metadata) {
+    const crossReferences = [];
+    const lines = content.split('\n');
+    // Track section counters for each level
+    const sectionCounters = { level1: 0, level2: 0, level3: 0 };
+    // Get level formats from metadata
+    const levelFormats = {
+        level1: metadata['level-one'] || 'Article %n.',
+        level2: metadata['level-two'] || 'Section %n.',
+        level3: metadata['level-three'] || '(%n)',
+    };
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Check for header lines with cross-reference keys
+        const headerMatch = trimmedLine.match(/^(l{1,3})\.\s+(.+?)\s+\|(\w+)\|$/);
+        if (headerMatch) {
+            const [, levelMarker, headerText, key] = headerMatch;
+            const level = levelMarker.length;
+            // Update section counters
+            if (level === 1) {
+                sectionCounters.level1++;
+                sectionCounters.level2 = 0; // Reset level 2 counter
+                sectionCounters.level3 = 0; // Reset level 3 counter
+            }
+            else if (level === 2) {
+                sectionCounters.level2++;
+                sectionCounters.level3 = 0; // Reset level 3 counter
+            }
+            else if (level === 3) {
+                sectionCounters.level3++;
+            }
+            // Generate section number based on level
+            let sectionNumber;
+            let sectionText;
+            if (level === 1) {
+                sectionNumber = levelFormats.level1.replace(/%n/g, sectionCounters.level1.toString());
+                sectionText = `${sectionNumber} ${headerText}`;
+            }
+            else if (level === 2) {
+                sectionNumber = levelFormats.level2.replace(/%n/g, sectionCounters.level2.toString());
+                sectionText = `${sectionNumber} ${headerText}`;
+            }
+            else {
+                sectionNumber = levelFormats.level3.replace(/%n/g, sectionCounters.level3.toString());
+                sectionText = `${sectionNumber} ${headerText}`;
+            }
+            crossReferences.push({
+                key,
+                sectionNumber: sectionNumber.trim(),
+                sectionText: sectionText.trim(),
+            });
+        }
+    }
+    return crossReferences;
+}
+/**
+ * Replaces cross-reference usage throughout the document
  *
- * console.log(getNestedValue(obj, "contract.parties.client.name")); // "Acme Corp"
- * console.log(getNestedValue(obj, "contract.terms.duration"));      // 12
- * console.log(getNestedValue(obj, "contract.nonexistent"));         // undefined
- * ```
+ * Scans the document for |key| references and replaces them with:
+ * 1. Section numbers from internal cross-references (priority)
+ * 2. Metadata values as fallback for backward compatibility
+ * 3. Original reference if neither is found
+ *
+ * @private
+ * @param {string} content - Document content to process
+ * @param {CrossReference[]} crossReferences - Map of keys to section numbers
+ * @param {Record<string, any>} metadata - Metadata for fallback resolution
+ * @returns {string} Document with cross-references replaced
+ */
+function replaceCrossReferences(content, crossReferences, metadata) {
+    // Create a map for quick lookups
+    const referenceMap = new Map();
+    for (const ref of crossReferences) {
+        referenceMap.set(ref.key, ref.sectionNumber);
+    }
+    // Replace all |key| references (except those in headers which define them)
+    const lines = content.split('\n');
+    const processedLines = lines.map(line => {
+        const trimmedLine = line.trim();
+        // Skip lines that define cross-references (headers with |key| syntax)
+        if (trimmedLine.match(/^(l{1,3})\.\s+(.+?)\s+\|(\w+)\|$/)) {
+            return line;
+        }
+        // Process cross-reference usage in content lines
+        return line.replace(/\|([^|]+)\|/g, (match, key) => {
+            const trimmedKey = key.trim();
+            // First try internal section reference
+            const sectionNumber = referenceMap.get(trimmedKey);
+            if (sectionNumber) {
+                return sectionNumber;
+            }
+            // Fallback to metadata value
+            const metadataValue = getNestedValue(metadata, trimmedKey);
+            if (metadataValue !== undefined) {
+                return formatMetadataValue(metadataValue, trimmedKey, metadata);
+            }
+            // Return original if no reference found
+            return match;
+        });
+    });
+    return processedLines.join('\n');
+}
+/**
+ * Gets a potentially nested value from an object using dot notation
  */
 function getNestedValue(obj, path) {
     const keys = path.split('.');
@@ -153,121 +203,28 @@ function getNestedValue(obj, path) {
     return value;
 }
 /**
- * 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"
- * ```
+ * Formats metadata values based on type and context
  */
-function formatReferenceValue(value, format) {
-    if (value === undefined || value === null) {
+function formatMetadataValue(value, key, metadata) {
+    if (value === undefined) {
         return '';
     }
-    // Handle different types
-    if (typeof value === 'object' && value instanceof Date) {
-        return formatDate(value, format);
+    if (value === null) {
+        return 'null';
     }
-    if (typeof value === 'number' && format?.startsWith('currency')) {
-        return formatCurrency(value, format);
+    // Handle Date objects
+    if (value instanceof Date) {
+        return value.toISOString().split('T')[0]; // ISO date format
     }
-    // Default: convert to string
-    return String(value);
-}
-/**
- * Formats a date value
- *
- * Converts a Date object to a formatted string using various format options.
- * Supports ISO format (default), short format, and long format for different
- * document presentation needs.
- *
- * @private
- * @param {Date} date - Date to format
- * @param {string} [format] - Date format specification ("short", "long", or default ISO)
- * @returns {string} Formatted date string
- * @example
- * ```typescript
- * const date = new Date("2024-03-15T10:30:00Z");
- *
- * console.log(formatDate(date));         // "2024-03-15" (ISO format)
- * console.log(formatDate(date, "short")); // "3/15/2024" (locale-specific)
- * console.log(formatDate(date, "long"));  // "March 15, 2024" (long format)
- * ```
- */
-function formatDate(date, format) {
-    if (!format) {
-        // Default format: YYYY-MM-DD
-        return date.toISOString().split('T')[0];
+    // Handle currency amounts
+    if (typeof value === 'number' && key.includes('amount')) {
+        const currency = metadata.payment_currency || 'USD';
+        return new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency,
+        }).format(value);
     }
-    // Custom date formatting
-    if (format === 'short') {
-        return date.toLocaleDateString();
-    }
-    else if (format === 'long') {
-        return date.toLocaleDateString(undefined, {
-            year: 'numeric',
-            month: 'long',
-            day: 'numeric',
-        });
-    }
-    return date.toISOString().split('T')[0]; // Default to ISO format
-}
-/**
- * Formats a number as currency
- *
- * Converts a numeric amount to a formatted currency string using the
- * Intl.NumberFormat API. Supports different currencies and locales
- * based on the format specification.
- *
- * @private
- * @param {number} amount - Amount to format
- * @param {string} [format] - Currency format specification ("currency:CODE:locale")
- * @returns {string} Formatted currency string
- * @example
- * ```typescript
- * console.log(formatCurrency(1500));                          // "$1,500.00" (default USD)
- * console.log(formatCurrency(1500, "currency:EUR"));         // "€1,500.00"
- * console.log(formatCurrency(1500, "currency:GBP:en-GB"));   // "£1,500.00"
- * console.log(formatCurrency(1500, "currency:JPY:ja-JP"));   // "¥1,500"
- * console.log(formatCurrency(1500, "currency:EUR:de-DE"));   // "1.500,00 €"
- * ```
- */
-function formatCurrency(amount, format) {
-    let currency = 'USD';
-    let locale = 'en-US';
-    // Parse format specification
-    if (format) {
-        const parts = format.split(':');
-        if (parts.length > 1) {
-            currency = parts[1].trim().toUpperCase();
-        }
-        if (parts.length > 2) {
-            locale = parts[2].trim();
-        }
-    }
-    // Format using Intl.NumberFormat
-    return new Intl.NumberFormat(locale, {
-        style: 'currency',
-        currency,
-    }).format(amount);
+    // Default string conversion
+    return String(value);
 }
 //# sourceMappingURL=reference-processor.js.map