legal-markdown-js 0.1.0

package/dist/extensions/batch-processor.js

@@ -0,0 +1,392 @@
+"use strict";
+/**
+ * @fileoverview Batch Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality for processing multiple Legal Markdown files
+ * in batch operations. It supports recursive directory processing, concurrent
+ * file operations, progress tracking, and error handling.
+ *
+ * Features:
+ * - Batch processing of multiple Legal Markdown files
+ * - Recursive directory traversal with pattern matching
+ * - Concurrent processing with configurable concurrency limits
+ * - Progress tracking and error reporting callbacks
+ * - Directory structure preservation in output
+ * - File extension filtering and exclusion patterns
+ * - Metadata export support for batch operations
+ * - Statistics and performance tracking
+ *
+ * @example
+ * ```typescript
+ * import { processBatch } from './batch-processor';
+ *
+ * // Basic batch processing
+ * const result = await processBatch({
+ *   inputDir: './legal-docs',
+ *   outputDir: './output',
+ *   extensions: ['.md'],
+ *   recursive: true
+ * });
+ *
+ * // Advanced batch processing with callbacks
+ * const result = await processBatch({
+ *   inputDir: './contracts',
+ *   outputDir: './processed-contracts',
+ *   extensions: ['.md', '.txt'],
+ *   recursive: true,
+ *   concurrency: 3,
+ *   exclude: ['temp', 'backup'],
+ *   onProgress: (processed, total, currentFile) => {
+ *     console.log(`Progress: ${processed}/${total} - ${currentFile}`);
+ *   },
+ *   onError: (file, error) => {
+ *     console.error(`Error processing ${file}:`, error.message);
+ *   }
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processBatch = processBatch;
+exports.getProcessingStats = getProcessingStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const index_1 = require("../index");
+const readdir = (0, util_1.promisify)(fs.readdir);
+const stat = (0, util_1.promisify)(fs.stat);
+const readFile = (0, util_1.promisify)(fs.readFile);
+const writeFile = (0, util_1.promisify)(fs.writeFile);
+/**
+ * Processes multiple legal markdown files in batch
+ *
+ * This function performs batch processing of Legal Markdown files with support
+ * for recursive directory traversal, concurrent processing, and progress tracking.
+ * It automatically handles file discovery, directory creation, and error management.
+ *
+ * @async
+ * @function processBatch
+ * @param {BatchProcessingOptions} options - Configuration options for batch processing
+ * @returns {Promise<BatchProcessingResult>} A promise that resolves to the processing result
+ * @throws {Error} When input directory doesn't exist or other setup errors occur
+ * @example
+ * ```typescript
+ * import { processBatch } from './batch-processor';
+ *
+ * // Process all .md files in a directory
+ * const result = await processBatch({
+ *   inputDir: './legal-documents',
+ *   outputDir: './processed-documents',
+ *   extensions: ['.md'],
+ *   recursive: true,
+ *   preserveStructure: true,
+ *   concurrency: 3,
+ *   onProgress: (processed, total, currentFile) => {
+ *     console.log(`Progress: ${processed}/${total} - ${path.basename(currentFile)}`);
+ *   },
+ *   onError: (file, error) => {
+ *     console.error(`Error processing ${file}:`, error.message);
+ *   }
+ * });
+ *
+ * console.log(`Processed ${result.totalProcessed} files successfully`);
+ * console.log(`${result.totalErrors} files failed processing`);
+ * ```
+ */
+async function processBatch(options) {
+    const startTime = Date.now();
+    const { inputDir, outputDir, extensions = ['.md', '.txt'], recursive = false, preserveStructure = true, exclude = [], concurrency = 5, onProgress, onError, ...processingOptions } = options;
+    // Validate input directory
+    if (!fs.existsSync(inputDir)) {
+        throw new Error(`Input directory does not exist: ${inputDir}`);
+    }
+    // Create output directory if it doesn't exist
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Find all files to process
+    const filesToProcess = await findFilesToProcess(inputDir, extensions, recursive, exclude);
+    if (filesToProcess.length === 0) {
+        return {
+            totalProcessed: 0,
+            totalErrors: 0,
+            successfulFiles: [],
+            failedFiles: [],
+            processingTime: Date.now() - startTime,
+        };
+    }
+    const result = {
+        totalProcessed: 0,
+        totalErrors: 0,
+        successfulFiles: [],
+        failedFiles: [],
+        processingTime: 0,
+    };
+    // Process files in batches with concurrency control
+    const semaphore = new Semaphore(concurrency);
+    const promises = filesToProcess.map(async (filePath) => {
+        await semaphore.acquire();
+        try {
+            await processFile(filePath, inputDir, outputDir, preserveStructure, processingOptions, result, onProgress, onError);
+        }
+        finally {
+            semaphore.release();
+        }
+    });
+    await Promise.all(promises);
+    result.processingTime = Date.now() - startTime;
+    return result;
+}
+/**
+ * Finds all files to process in the given directory
+ *
+ * Recursively searches through directories to find files matching the specified
+ * extensions while respecting exclusion patterns and recursive settings.
+ *
+ * @async
+ * @function findFilesToProcess
+ * @param {string} dir - Directory to search in
+ * @param {string[]} extensions - File extensions to include (e.g., ['.md', '.txt'])
+ * @param {boolean} recursive - Whether to search subdirectories recursively
+ * @param {string[]} exclude - Patterns to exclude from search
+ * @returns {Promise<string[]>} Array of file paths matching the criteria
+ * @private
+ */
+async function findFilesToProcess(dir, extensions, recursive, exclude) {
+    const files = [];
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        // Skip excluded files/directories
+        if (exclude.some(pattern => entry.includes(pattern))) {
+            continue;
+        }
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+            if (recursive) {
+                const subFiles = await findFilesToProcess(fullPath, extensions, recursive, exclude);
+                files.push(...subFiles);
+            }
+        }
+        else if (stats.isFile()) {
+            const ext = path.extname(entry);
+            if (extensions.includes(ext)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Processes a single file and writes the output
+ *
+ * Handles the processing of an individual Legal Markdown file, including reading
+ * the source file, processing it through the Legal Markdown system, determining
+ * the output path, and writing the processed content and any exported files.
+ *
+ * @async
+ * @function processFile
+ * @param {string} filePath - Path to the input file to process
+ * @param {string} inputDir - Base input directory path
+ * @param {string} outputDir - Base output directory path
+ * @param {boolean} preserveStructure - Whether to preserve directory structure in output
+ * @param {LegalMarkdownOptions} processingOptions - Options for Legal Markdown processing
+ * @param {BatchProcessingResult} result - Result object to update with processing outcome
+ * @param {Function} [onProgress] - Optional callback for progress updates
+ * @param {Function} [onError] - Optional callback for error handling
+ * @returns {Promise<void>} Promise that resolves when processing is complete
+ * @private
+ */
+async function processFile(filePath, inputDir, outputDir, preserveStructure, processingOptions, result, onProgress, onError) {
+    try {
+        // Read file content
+        const content = await readFile(filePath, 'utf8');
+        // Process the content
+        const processedResult = (0, index_1.processLegalMarkdown)(content, {
+            ...processingOptions,
+            basePath: path.dirname(filePath),
+        });
+        // Determine output file path
+        const relativePath = path.relative(inputDir, filePath);
+        const outputFilePath = preserveStructure
+            ? path.join(outputDir, relativePath)
+            : path.join(outputDir, path.basename(filePath));
+        // Create output directory if needed
+        const outputFileDir = path.dirname(outputFilePath);
+        if (!fs.existsSync(outputFileDir)) {
+            fs.mkdirSync(outputFileDir, { recursive: true });
+        }
+        // Write processed content
+        await writeFile(outputFilePath, processedResult.content);
+        // Export metadata if generated
+        if (processedResult.exportedFiles && processedResult.exportedFiles.length > 0) {
+            // Handle exported metadata files
+            for (const exportedFile of processedResult.exportedFiles) {
+                const exportedOutputPath = preserveStructure
+                    ? path.join(outputDir, path.relative(inputDir, exportedFile))
+                    : path.join(outputDir, path.basename(exportedFile));
+                // Copy exported file to output directory
+                if (fs.existsSync(exportedFile)) {
+                    const exportedContent = await readFile(exportedFile, 'utf8');
+                    await writeFile(exportedOutputPath, exportedContent);
+                }
+            }
+        }
+        result.totalProcessed++;
+        result.successfulFiles.push(filePath);
+        if (onProgress) {
+            onProgress(result.totalProcessed + result.totalErrors, -1, filePath);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.totalErrors++;
+        result.failedFiles.push({
+            file: filePath,
+            error: errorMessage,
+        });
+        if (onError) {
+            onError(filePath, error instanceof Error ? error : new Error(String(error)));
+        }
+        if (onProgress) {
+            onProgress(result.totalProcessed + result.totalErrors, -1, filePath);
+        }
+    }
+}
+/**
+ * Simple semaphore for controlling concurrency
+ *
+ * Provides a mechanism to limit the number of concurrent operations by using
+ * a permit-based system. Useful for controlling resource usage during batch processing.
+ *
+ * @class Semaphore
+ * @private
+ * @example
+ * ```typescript
+ * const semaphore = new Semaphore(3); // Allow max 3 concurrent operations
+ *
+ * async function performOperation() {
+ *   await semaphore.acquire();
+ *   try {
+ *     // Perform the operation
+ *     await someAsyncOperation();
+ *   } finally {
+ *     semaphore.release();
+ *   }
+ * }
+ * ```
+ */
+class Semaphore {
+    /**
+     * Creates a new Semaphore instance
+     *
+     * @param {number} permits - Maximum number of concurrent operations allowed
+     */
+    constructor(permits) {
+        this.waiting = [];
+        this.permits = permits;
+    }
+    /**
+     * Acquires a permit, waiting if necessary
+     *
+     * @async
+     * @method acquire
+     * @returns {Promise<void>} Promise that resolves when a permit is acquired
+     */
+    async acquire() {
+        if (this.permits > 0) {
+            this.permits--;
+            return;
+        }
+        return new Promise(resolve => {
+            this.waiting.push(resolve);
+        });
+    }
+    /**
+     * Releases a permit, allowing waiting operations to proceed
+     *
+     * @method release
+     * @returns {void}
+     */
+    release() {
+        this.permits++;
+        if (this.waiting.length > 0) {
+            const next = this.waiting.shift();
+            if (next) {
+                this.permits--;
+                next();
+            }
+        }
+    }
+}
+/**
+ * Utility function to get processing statistics from batch processing results
+ *
+ * Calculates useful statistics about the batch processing operation including
+ * success rate, average processing time per file, and throughput metrics.
+ *
+ * @function getProcessingStats
+ * @param {BatchProcessingResult} result - The batch processing result to analyze
+ * @returns {Object} Object containing processing statistics
+ * @returns {number} returns.successRate - Success rate as a percentage (0-100)
+ * @returns {number} returns.averageTimePerFile - Average processing time per file in milliseconds
+ * @returns {number} returns.filesPerSecond - Processing throughput in files per second
+ * @example
+ * ```typescript
+ * import { processBatch, getProcessingStats } from './batch-processor';
+ *
+ * const result = await processBatch({
+ *   inputDir: './documents',
+ *   outputDir: './output'
+ * });
+ *
+ * const stats = getProcessingStats(result);
+ * console.log(`Success rate: ${stats.successRate.toFixed(2)}%`);
+ * console.log(`Average time per file: ${stats.averageTimePerFile.toFixed(2)}ms`);
+ * console.log(`Throughput: ${stats.filesPerSecond.toFixed(2)} files/second`);
+ * ```
+ */
+function getProcessingStats(result) {
+    const totalFiles = result.totalProcessed + result.totalErrors;
+    const successRate = totalFiles > 0 ? (result.totalProcessed / totalFiles) * 100 : 0;
+    const averageTimePerFile = totalFiles > 0 ? result.processingTime / totalFiles : 0;
+    const filesPerSecond = result.processingTime > 0 ? (totalFiles / result.processingTime) * 1000 : 0;
+    return {
+        successRate,
+        averageTimePerFile,
+        filesPerSecond,
+    };
+}
+//# sourceMappingURL=batch-processor.js.map

package/dist/extensions/batch-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processor.js","sourceRoot":"","sources":["../../src/extensions/batch-processor.ts"],"names":[],"mappings":"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"}

package/dist/extensions/formatters/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview Output Formatters for Legal Documents
+ *
+ * This module provides enhanced formatting capabilities for Legal Markdown documents
+ * beyond the core functionality. It includes formatters for different output styles,
+ * HTML generation, and document presentation optimizations.
+ *
+ * Features:
+ * - Enhanced document styling with line spacing options
+ * - Page break insertion for print-friendly output
+ * - HTML generation with legal-specific styling
+ * - Header formatting with multiple style options
+ * - Extensions not present in the original legal-markdown
+ * - Print-optimized document formatting
+ *
+ * @example
+ * ```typescript
+ * import { formatLegalDocument, toLegalHTML } from './formatters';
+ *
+ * // Format document with double line spacing
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double',
+ *   pageBreaks: true,
+ *   headerStyle: 'bold'
+ * });
+ *
+ * // Convert to HTML with legal styling
+ * const html = toLegalHTML(content);
+ * ```
+ */
+/**
+ * Formats legal document output with enhanced styling options
+ *
+ * This function provides advanced formatting capabilities for Legal Markdown documents,
+ * including line spacing control, page break insertion, and header styling. These
+ * features are extensions not present in the original legal-markdown specification.
+ *
+ * @function formatLegalDocument
+ * @param {string} content - The legal document content to format
+ * @param {Object} [options={}] - Formatting options
+ * @param {'single' | 'double'} [options.lineSpacing='single'] - Line spacing style
+ * @param {boolean} [options.pageBreaks=false] - Whether to add page breaks before major sections
+ * @param {'bold' | 'underline' | 'both'} [options.headerStyle] - Header styling option
+ * @returns {string} The formatted document content
+ * @example
+ * ```typescript
+ * import { formatLegalDocument } from './formatters';
+ *
+ * // Basic formatting with double line spacing
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double'
+ * });
+ *
+ * // Advanced formatting with page breaks and header styling
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double',
+ *   pageBreaks: true,
+ *   headerStyle: 'bold'
+ * });
+ *
+ * // Print-friendly formatting
+ * const printReady = formatLegalDocument(content, {
+ *   lineSpacing: 'single',
+ *   pageBreaks: true
+ * });
+ * ```
+ */
+export declare function formatLegalDocument(content: string, options?: {
+    lineSpacing?: 'single' | 'double';
+    pageBreaks?: boolean;
+    headerStyle?: 'bold' | 'underline' | 'both';
+}): string;
+/**
+ * Converts legal document to HTML with legal-specific styling
+ *
+ * Generates a complete HTML document with professional legal document styling,
+ * including Times New Roman font, proper line spacing, and structured layout
+ * with appropriate margins and indentation for legal document presentation.
+ *
+ * @function toLegalHTML
+ * @param {string} content - The legal document content to convert to HTML
+ * @returns {string} Complete HTML document with embedded styles
+ * @example
+ * ```typescript
+ * import { toLegalHTML } from './formatters';
+ *
+ * // Convert processed legal markdown to HTML
+ * const htmlDocument = toLegalHTML(processedContent);
+ *
+ * // Save to file
+ * fs.writeFileSync('contract.html', htmlDocument);
+ *
+ * // Or serve via web server
+ * res.setHeader('Content-Type', 'text/html');
+ * res.send(htmlDocument);
+ * ```
+ */
+export declare function toLegalHTML(content: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/formatters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;CACxC,GACL,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBnD"}

package/dist/extensions/formatters/index.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * @fileoverview Output Formatters for Legal Documents
+ *
+ * This module provides enhanced formatting capabilities for Legal Markdown documents
+ * beyond the core functionality. It includes formatters for different output styles,
+ * HTML generation, and document presentation optimizations.
+ *
+ * Features:
+ * - Enhanced document styling with line spacing options
+ * - Page break insertion for print-friendly output
+ * - HTML generation with legal-specific styling
+ * - Header formatting with multiple style options
+ * - Extensions not present in the original legal-markdown
+ * - Print-optimized document formatting
+ *
+ * @example
+ * ```typescript
+ * import { formatLegalDocument, toLegalHTML } from './formatters';
+ *
+ * // Format document with double line spacing
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double',
+ *   pageBreaks: true,
+ *   headerStyle: 'bold'
+ * });
+ *
+ * // Convert to HTML with legal styling
+ * const html = toLegalHTML(content);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLegalDocument = formatLegalDocument;
+exports.toLegalHTML = toLegalHTML;
+// Output formatters - Extensions for output formatting beyond core functionality
+/**
+ * Formats legal document output with enhanced styling options
+ *
+ * This function provides advanced formatting capabilities for Legal Markdown documents,
+ * including line spacing control, page break insertion, and header styling. These
+ * features are extensions not present in the original legal-markdown specification.
+ *
+ * @function formatLegalDocument
+ * @param {string} content - The legal document content to format
+ * @param {Object} [options={}] - Formatting options
+ * @param {'single' | 'double'} [options.lineSpacing='single'] - Line spacing style
+ * @param {boolean} [options.pageBreaks=false] - Whether to add page breaks before major sections
+ * @param {'bold' | 'underline' | 'both'} [options.headerStyle] - Header styling option
+ * @returns {string} The formatted document content
+ * @example
+ * ```typescript
+ * import { formatLegalDocument } from './formatters';
+ *
+ * // Basic formatting with double line spacing
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double'
+ * });
+ *
+ * // Advanced formatting with page breaks and header styling
+ * const formatted = formatLegalDocument(content, {
+ *   lineSpacing: 'double',
+ *   pageBreaks: true,
+ *   headerStyle: 'bold'
+ * });
+ *
+ * // Print-friendly formatting
+ * const printReady = formatLegalDocument(content, {
+ *   lineSpacing: 'single',
+ *   pageBreaks: true
+ * });
+ * ```
+ */
+function formatLegalDocument(content, options = {}) {
+    let formatted = content;
+    if (options.lineSpacing === 'double') {
+        formatted = formatted.replace(/\n/g, '\n\n');
+    }
+    if (options.pageBreaks) {
+        // Add page breaks before major sections
+        formatted = formatted.replace(/^Article \d+\./gm, '\n---PAGE BREAK---\n$&');
+    }
+    return formatted;
+}
+/**
+ * Converts legal document to HTML with legal-specific styling
+ *
+ * Generates a complete HTML document with professional legal document styling,
+ * including Times New Roman font, proper line spacing, and structured layout
+ * with appropriate margins and indentation for legal document presentation.
+ *
+ * @function toLegalHTML
+ * @param {string} content - The legal document content to convert to HTML
+ * @returns {string} Complete HTML document with embedded styles
+ * @example
+ * ```typescript
+ * import { toLegalHTML } from './formatters';
+ *
+ * // Convert processed legal markdown to HTML
+ * const htmlDocument = toLegalHTML(processedContent);
+ *
+ * // Save to file
+ * fs.writeFileSync('contract.html', htmlDocument);
+ *
+ * // Or serve via web server
+ * res.setHeader('Content-Type', 'text/html');
+ * res.send(htmlDocument);
+ * ```
+ */
+function toLegalHTML(content) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+    <title>Legal Document</title>
+    <style>
+        body { font-family: 'Times New Roman', serif; line-height: 1.6; }
+        .article { margin: 20px 0; }
+        .section { margin-left: 20px; }
+        .subsection { margin-left: 40px; }
+    </style>
+</head>
+<body>
+    <div class="legal-document">
+        ${content.replace(/\n/g, '<br>')}
+    </div>
+</body>
+</html>`;
+}
+//# sourceMappingURL=index.js.map

package/dist/extensions/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/formatters/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;;AAyCH,kDAoBC;AA2BD,kCAkBC;AAxGD,iFAAiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,SAAgB,mBAAmB,CACjC,OAAe,EACf,UAII,EAAE;IAEN,IAAI,SAAS,GAAG,OAAO,CAAC;IAExB,IAAI,OAAO,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;QACrC,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACvB,wCAAwC;QACxC,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,kBAAkB,EAAE,wBAAwB,CAAC,CAAC;IAC9E,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,WAAW,CAAC,OAAe;IACzC,OAAO;;;;;;;;;;;;;UAaC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC;;;QAGhC,CAAC;AACT,CAAC"}