legal-markdown-js 0.1.0

package/dist/extensions/utilities/index.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * @fileoverview Utility Functions for Legal Document Analysis
+ *
+ * This module provides utility functions for analyzing and extracting information
+ * from Legal Markdown documents. These are extensions beyond the core functionality
+ * that provide insights into document structure, content, and usage patterns.
+ *
+ * Features:
+ * - Document statistics and analysis
+ * - Reference extraction and analysis
+ * - Condition extraction from optional clauses
+ * - Word count and character count metrics
+ * - Header and structure analysis
+ * - Import usage tracking
+ * - Extensions not present in the original legal-markdown
+ *
+ * @example
+ * ```typescript
+ * import { analyzeDocument, extractReferences, extractConditions } from './utilities';
+ *
+ * // Analyze document statistics
+ * const stats = analyzeDocument(content);
+ * console.log(`Document contains ${stats.wordCount} words and ${stats.headerCount} headers`);
+ *
+ * // Extract references
+ * const references = extractReferences(content);
+ * console.log('References used:', references);
+ *
+ * // Extract conditions
+ * const conditions = extractConditions(content);
+ * console.log('Conditions used:', conditions);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDocument = analyzeDocument;
+exports.extractReferences = extractReferences;
+exports.extractConditions = extractConditions;
+// Utility functions - Extensions for utility functions beyond core functionality
+/**
+ * Analyzes document statistics and structure
+ *
+ * Provides comprehensive analysis of Legal Markdown document content including
+ * word counts, structural elements, and usage patterns. This is an extension
+ * not present in the original legal-markdown specification.
+ *
+ * @function analyzeDocument
+ * @param {string} content - The legal document content to analyze
+ * @returns {Object} Object containing document statistics
+ * @returns {number} returns.wordCount - Total number of words in the document
+ * @returns {number} returns.characterCount - Total number of characters in the document
+ * @returns {number} returns.headerCount - Number of header structures (l., ll., etc.)
+ * @returns {number} returns.optionalClauseCount - Number of optional clauses found
+ * @returns {number} returns.crossReferenceCount - Number of cross-references found
+ * @returns {number} returns.importCount - Number of import statements found
+ * @example
+ * ```typescript
+ * import { analyzeDocument } from './utilities';
+ *
+ * const stats = analyzeDocument(documentContent);
+ * console.log(`Document Analysis:`);
+ * console.log(`- Words: ${stats.wordCount}`);
+ * console.log(`- Characters: ${stats.characterCount}`);
+ * console.log(`- Headers: ${stats.headerCount}`);
+ * console.log(`- Optional Clauses: ${stats.optionalClauseCount}`);
+ * console.log(`- Cross References: ${stats.crossReferenceCount}`);
+ * console.log(`- Imports: ${stats.importCount}`);
+ * ```
+ */
+function analyzeDocument(content) {
+    const words = content.split(/\s+/).filter(word => word.length > 0);
+    const headers = content.match(/^l+\./gm) || [];
+    const optionalClauses = content.match(/\[.*?\]\{.*?\}/g) || [];
+    const crossReferences = content.match(/\|.*?\|/g) || [];
+    const imports = content.match(/@import\s+/g) || [];
+    return {
+        wordCount: words.length,
+        characterCount: content.length,
+        headerCount: headers.length,
+        optionalClauseCount: optionalClauses.length,
+        crossReferenceCount: crossReferences.length,
+        importCount: imports.length,
+    };
+}
+/**
+ * Extracts all references used in a document
+ *
+ * Scans the document content for cross-reference patterns and returns a unique
+ * list of all references found. Useful for understanding document dependencies
+ * and reference usage patterns.
+ *
+ * @function extractReferences
+ * @param {string} content - The legal document content to analyze
+ * @returns {string[]} Array of unique reference names found in the document
+ * @example
+ * ```typescript
+ * import { extractReferences } from './utilities';
+ *
+ * const references = extractReferences(documentContent);
+ * console.log('References used in document:', references);
+ *
+ * // Example output: ['section-1', 'definitions', 'termination-clause']
+ * ```
+ */
+function extractReferences(content) {
+    const references = content.match(/\|(.*?)\|/g) || [];
+    return references
+        .map(ref => ref.slice(1, -1))
+        .filter((ref, index, arr) => arr.indexOf(ref) === index);
+}
+/**
+ * Extracts all conditions used in optional clauses
+ *
+ * Scans the document content for conditional clause patterns and returns a unique
+ * list of all conditions found. Useful for understanding document logic and
+ * conditional content usage.
+ *
+ * @function extractConditions
+ * @param {string} content - The legal document content to analyze
+ * @returns {string[]} Array of unique condition names found in the document
+ * @example
+ * ```typescript
+ * import { extractConditions } from './utilities';
+ *
+ * const conditions = extractConditions(documentContent);
+ * console.log('Conditions used in document:', conditions);
+ *
+ * // Example output: ['include-warranty', 'corporate-client', 'international-law']
+ * ```
+ */
+function extractConditions(content) {
+    const conditions = content.match(/\{(.*?)\}/g) || [];
+    return conditions
+        .map(cond => cond.slice(1, -1))
+        .filter((cond, index, arr) => arr.indexOf(cond) === index);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/utilities/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;AAkCH,0CAsBC;AAsBD,8CAKC;AAsBD,8CAKC;AA5GD,iFAAiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,SAAgB,eAAe,CAAC,OAAe;IAQ7C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACnE,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC/C,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;IAC/D,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACxD,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAEnD,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,MAAM;QACvB,cAAc,EAAE,OAAO,CAAC,MAAM;QAC9B,WAAW,EAAE,OAAO,CAAC,MAAM;QAC3B,mBAAmB,EAAE,eAAe,CAAC,MAAM;QAC3C,mBAAmB,EAAE,eAAe,CAAC,MAAM;QAC3C,WAAW,EAAE,OAAO,CAAC,MAAM;KAC5B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,iBAAiB,CAAC,OAAe;IAC/C,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IACrD,OAAO,UAAU;SACd,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC5B,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,iBAAiB,CAAC,OAAe;IAC/C,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IACrD,OAAO,UAAU;SACd,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC9B,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC;AAC/D,CAAC"}

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

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Document Validators for Legal Markdown
+ *
+ * This module provides validation functions for Legal Markdown documents to ensure
+ * proper structure, syntax, and content integrity. These validators are extensions
+ * beyond the core functionality that help identify potential issues before processing.
+ *
+ * Features:
+ * - Document structure validation
+ * - Syntax checking for brackets and braces
+ * - Content integrity verification
+ * - Error reporting with detailed messages
+ * - Extensions not present in the original legal-markdown
+ * - Validation rules for legal document conventions
+ *
+ * @example
+ * ```typescript
+ * import { validateDocumentStructure } from './validators';
+ *
+ * // Validate document structure
+ * const validation = validateDocumentStructure(content);
+ * if (!validation.isValid) {
+ *   console.error('Document validation failed:');
+ *   validation.errors.forEach(error => console.error(`- ${error}`));
+ * }
+ * ```
+ */
+/**
+ * Validates document structure and content integrity
+ *
+ * Performs comprehensive validation of Legal Markdown document structure including
+ * syntax checking, bracket matching, and content integrity verification. This is
+ * an extension not present in the original legal-markdown specification.
+ *
+ * @function validateDocumentStructure
+ * @param {string} content - The legal document content to validate
+ * @returns {Object} Validation result object
+ * @returns {boolean} returns.isValid - Whether the document passes all validation checks
+ * @returns {string[]} returns.errors - Array of validation error messages
+ * @example
+ * ```typescript
+ * import { validateDocumentStructure } from './validators';
+ *
+ * const validation = validateDocumentStructure(documentContent);
+ *
+ * if (validation.isValid) {
+ *   console.log('Document structure is valid');
+ * } else {
+ *   console.error('Document validation failed:');
+ *   validation.errors.forEach(error => {
+ *     console.error(`- ${error}`);
+ *   });
+ * }
+ *
+ * // Example validation errors:
+ * // - Document cannot be empty
+ * // - Unmatched optional clause brackets
+ * // - Unmatched conditional braces
+ * ```
+ */
+export declare function validateDocumentStructure(content: string): {
+    isValid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/validators/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA0BjG"}

package/dist/extensions/validators/index.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * @fileoverview Document Validators for Legal Markdown
+ *
+ * This module provides validation functions for Legal Markdown documents to ensure
+ * proper structure, syntax, and content integrity. These validators are extensions
+ * beyond the core functionality that help identify potential issues before processing.
+ *
+ * Features:
+ * - Document structure validation
+ * - Syntax checking for brackets and braces
+ * - Content integrity verification
+ * - Error reporting with detailed messages
+ * - Extensions not present in the original legal-markdown
+ * - Validation rules for legal document conventions
+ *
+ * @example
+ * ```typescript
+ * import { validateDocumentStructure } from './validators';
+ *
+ * // Validate document structure
+ * const validation = validateDocumentStructure(content);
+ * if (!validation.isValid) {
+ *   console.error('Document validation failed:');
+ *   validation.errors.forEach(error => console.error(`- ${error}`));
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDocumentStructure = validateDocumentStructure;
+// Document validators - Extensions for validation beyond core functionality
+/**
+ * Validates document structure and content integrity
+ *
+ * Performs comprehensive validation of Legal Markdown document structure including
+ * syntax checking, bracket matching, and content integrity verification. This is
+ * an extension not present in the original legal-markdown specification.
+ *
+ * @function validateDocumentStructure
+ * @param {string} content - The legal document content to validate
+ * @returns {Object} Validation result object
+ * @returns {boolean} returns.isValid - Whether the document passes all validation checks
+ * @returns {string[]} returns.errors - Array of validation error messages
+ * @example
+ * ```typescript
+ * import { validateDocumentStructure } from './validators';
+ *
+ * const validation = validateDocumentStructure(documentContent);
+ *
+ * if (validation.isValid) {
+ *   console.log('Document structure is valid');
+ * } else {
+ *   console.error('Document validation failed:');
+ *   validation.errors.forEach(error => {
+ *     console.error(`- ${error}`);
+ *   });
+ * }
+ *
+ * // Example validation errors:
+ * // - Document cannot be empty
+ * // - Unmatched optional clause brackets
+ * // - Unmatched conditional braces
+ * ```
+ */
+function validateDocumentStructure(content) {
+    const errors = [];
+    // Basic validation rules
+    if (!content.trim()) {
+        errors.push('Document cannot be empty');
+    }
+    // Check for unmatched optional clause brackets
+    const openBrackets = (content.match(/\[/g) || []).length;
+    const closeBrackets = (content.match(/\]/g) || []).length;
+    if (openBrackets !== closeBrackets) {
+        errors.push('Unmatched optional clause brackets');
+    }
+    // Check for unmatched conditional braces
+    const openBraces = (content.match(/\{/g) || []).length;
+    const closeBraces = (content.match(/\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+        errors.push('Unmatched conditional braces');
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/validators/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;AAqCH,8DA0BC;AA7DD,4EAA4E;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,SAAgB,yBAAyB,CAAC,OAAe;IACvD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,yBAAyB;IACzB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;IAC1C,CAAC;IAED,+CAA+C;IAC/C,MAAM,YAAY,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IACzD,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAC1D,IAAI,YAAY,KAAK,aAAa,EAAE,CAAC;QACnC,MAAM,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;IACpD,CAAC;IAED,yCAAyC;IACzC,MAAM,UAAU,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IACvD,MAAM,WAAW,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IACxD,IAAI,UAAU,KAAK,WAAW,EAAE,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;IAC9C,CAAC;IAED,OAAO;QACL,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;QAC5B,MAAM;KACP,CAAC;AACJ,CAAC"}

package/dist/generators/html-generator.d.ts

@@ -0,0 +1,184 @@
+/**
+ * @fileoverview HTML Generation Module for Legal Markdown Documents
+ *
+ * This module provides functionality to convert processed Legal Markdown content
+ * into well-formatted HTML documents with CSS styling, accessibility features,
+ * and print optimization.
+ *
+ * Features:
+ * - Markdown to HTML conversion using marked
+ * - DOM manipulation with cheerio for enhanced formatting
+ * - Custom CSS injection and styling
+ * - Field highlighting for document review
+ * - Print-friendly output with page break controls
+ * - Responsive table handling
+ * - Accessibility improvements
+ *
+ * @example
+ * ```typescript
+ * import { htmlGenerator } from './html-generator';
+ *
+ * const html = await htmlGenerator.generateHtml(markdownContent, {
+ *   title: 'Legal Agreement',
+ *   cssPath: './styles.css',
+ *   includeHighlighting: true
+ * });
+ * ```
+ */
+/**
+ * Configuration options for HTML generation
+ *
+ * @interface HtmlGeneratorOptions
+ */
+export interface HtmlGeneratorOptions {
+    /** Path to custom CSS file to include in the generated HTML */
+    cssPath?: string;
+    /** Path to highlighting CSS file for field highlighting */
+    highlightCssPath?: string;
+    /** Whether to include field highlighting styles */
+    includeHighlighting?: boolean;
+    /** Document title for the HTML page */
+    title?: string;
+    /** Additional metadata to include in HTML head */
+    metadata?: Record<string, string>;
+}
+/**
+ * HTML Generator for Legal Markdown Documents
+ *
+ * Converts processed Legal Markdown content into formatted HTML documents
+ * with professional styling, accessibility features, and print optimization.
+ *
+ * @class HtmlGenerator
+ * @example
+ * ```typescript
+ * const generator = new HtmlGenerator();
+ * const html = await generator.generateHtml(content, {
+ *   title: 'Contract',
+ *   includeHighlighting: true
+ * });
+ * ```
+ */
+export declare class HtmlGenerator {
+    /**
+     * Creates a new HTML generator instance and configures the markdown parser
+     *
+     * @constructor
+     */
+    constructor();
+    /**
+     * Configures the marked markdown parser with options optimized for legal documents
+     *
+     * @private
+     * @method configureMarked
+     * @returns {void}
+     */
+    private configureMarked;
+    /**
+     * Removes YAML frontmatter from markdown content if present
+     *
+     * @private
+     * @method removeYamlFrontmatter
+     * @param {string} content - The markdown content that may contain YAML frontmatter
+     * @returns {string} Content with YAML frontmatter removed
+     * @example
+     * ```typescript
+     * const content = `---
+     * title: Document
+     * ---
+     * # Content`;
+     * const clean = this.removeYamlFrontmatter(content); // "# Content"
+     * ```
+     */
+    private removeYamlFrontmatter;
+    /**
+     * Generates a complete HTML document from Legal Markdown content
+     *
+     * This is the main method that orchestrates the conversion process:
+     * 1. Removes YAML frontmatter
+     * 2. Converts markdown to HTML using marked
+     * 3. Applies DOM transformations for legal document formatting
+     * 4. Injects custom CSS and styling
+     * 5. Builds a complete HTML document
+     *
+     * @async
+     * @method generateHtml
+     * @param {string} markdownContent - The processed Legal Markdown content to convert
+     * @param {HtmlGeneratorOptions} [options={}] - Configuration options for HTML generation
+     * @returns {Promise<string>} A promise that resolves to the complete HTML document
+     * @throws {Error} When HTML generation fails due to parsing or file system errors
+     * @example
+     * ```typescript
+     * const html = await generator.generateHtml(
+     *   '# Contract\n\nThis is a {{party.name}} agreement.',
+     *   {
+     *     title: 'Service Agreement',
+     *     cssPath: './contract-styles.css',
+     *     includeHighlighting: true,
+     *     metadata: {
+     *       author: 'Legal Team',
+     *       version: '1.0'
+     *     }
+     *   }
+     * );
+     * ```
+     */
+    generateHtml(markdownContent: string, options?: HtmlGeneratorOptions): Promise<string>;
+    /**
+     * Applies DOM transformations to enhance the HTML for legal document presentation
+     *
+     * Transformations include:
+     * - Adding no-break classes to short lists for better print layout
+     * - Wrapping tables in responsive containers
+     * - Adding alt attributes to images for accessibility
+     * - Adding print-friendly CSS classes
+     * - Cleaning up paragraph tags in list items
+     *
+     * @private
+     * @method applyDomTransformations
+     * @param {cheerio.CheerioAPI} $ - The cheerio instance with loaded HTML
+     * @returns {void}
+     */
+    private applyDomTransformations;
+    /**
+     * Loads CSS content from a file path
+     *
+     * @private
+     * @async
+     * @method loadCss
+     * @param {string} cssPath - Path to the CSS file to load
+     * @returns {Promise<string>} A promise that resolves to the CSS content, or empty string on error
+     */
+    private loadCss;
+    /**
+     * Builds a complete HTML document with head, body, and embedded styles
+     *
+     * Creates a well-formed HTML5 document with:
+     * - Proper DOCTYPE and meta tags
+     * - Responsive viewport configuration
+     * - Embedded CSS styles (base + custom)
+     * - SEO-friendly metadata
+     * - Print-optimized styling
+     *
+     * @private
+     * @method buildHtmlDocument
+     * @param {Object} options - Configuration for building the HTML document
+     * @param {string} options.body - The HTML body content
+     * @param {string} options.css - Custom CSS to embed
+     * @param {string} options.title - Document title
+     * @param {Record<string, string>} [options.metadata] - Additional metadata for HTML head
+     * @returns {string} Complete HTML document as string
+     */
+    private buildHtmlDocument;
+}
+/**
+ * Singleton instance of HtmlGenerator for convenient importing
+ *
+ * @constant {HtmlGenerator} htmlGenerator
+ * @example
+ * ```typescript
+ * import { htmlGenerator } from './html-generator';
+ * const html = await htmlGenerator.generateHtml(content);
+ * ```
+ */
+export declare const htmlGenerator: HtmlGenerator;
+//# sourceMappingURL=html-generator.d.ts.map

package/dist/generators/html-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-generator.d.ts","sourceRoot":"","sources":["../../src/generators/html-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AASH;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAa;IACxB;;;;OAIG;;IAKH;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IASvB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,qBAAqB;IA0B7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,YAAY,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiEhG;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAgC/B;;;;;;;;OAQG;YACW,OAAO;IAWrB;;;;;;;;;;;;;;;;;;OAkBG;YACW,iBAAiB;CAwChC;AAED;;;;;;;;;GASG;AAEH,eAAO,MAAM,aAAa,eAAsB,CAAC"}