legal-markdown-js 0.1.0

package/dist/lib/index.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Utility Library for Legal Markdown Processing
+ *
+ * This module provides essential utility functions for file operations,
+ * path handling, data manipulation, and common programming patterns used
+ * throughout the Legal Markdown processing system.
+ *
+ * Features:
+ * - File system operations with error handling
+ * - Path resolution and manipulation utilities
+ * - Data transformation and merging functions
+ * - Input validation and sanitization
+ * - Performance optimization utilities (debounce)
+ * - URL validation and file extension handling
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   readFileSync,
+ *   writeFileSync,
+ *   resolveFilePath,
+ *   deepMerge,
+ *   sanitizeFileName
+ * } from './lib';
+ *
+ * // Read a file safely
+ * const content = readFileSync('./document.md');
+ *
+ * // Resolve relative paths
+ * const fullPath = resolveFilePath('./docs', 'contract.md');
+ *
+ * // Merge configuration objects
+ * const config = deepMerge(defaultConfig, userConfig);
+ * ```
+ */
+/**
+ * Ensures that a directory exists, creating it recursively if necessary
+ *
+ * @param {string} dirPath - The directory path to ensure exists
+ * @returns {void}
+ * @example
+ * ```typescript
+ * ensureDirectoryExists('./output/documents');
+ * ```
+ */
+export declare function ensureDirectoryExists(dirPath: string): void;
+/**
+ * Reads a file synchronously with proper error handling
+ *
+ * @param {string} filePath - The path to the file to read
+ * @returns {string} The file content as UTF-8 string
+ * @throws {FileNotFoundError} When the file does not exist
+ * @throws {Error} For other file system errors
+ * @example
+ * ```typescript
+ * const content = readFileSync('./document.md');
+ * ```
+ */
+export declare function readFileSync(filePath: string): string;
+/**
+ * Writes content to a file synchronously, creating directories as needed
+ *
+ * @param {string} filePath - The path where the file will be written
+ * @param {string} content - The content to write to the file
+ * @returns {void}
+ * @example
+ * ```typescript
+ * writeFileSync('./output/document.md', processedContent);
+ * ```
+ */
+export declare function writeFileSync(filePath: string, content: string): void;
+/**
+ * Resolves a file path relative to a base directory
+ *
+ * @param {string | undefined} basePath - The base directory path (defaults to cwd)
+ * @param {string} filePath - The file path to resolve
+ * @returns {string} The resolved absolute path
+ * @example
+ * ```typescript
+ * const fullPath = resolveFilePath('./docs', 'contract.md');
+ * // Returns: '/path/to/docs/contract.md'
+ * ```
+ */
+export declare function resolveFilePath(basePath: string | undefined, filePath: string): string;
+/**
+ * Gets the file extension from a file path in lowercase
+ *
+ * @param {string} filePath - The file path to extract extension from
+ * @returns {string} The file extension in lowercase (including the dot)
+ * @example
+ * ```typescript
+ * const ext = getFileExtension('document.MD');
+ * // Returns: '.md'
+ * ```
+ */
+export declare function getFileExtension(filePath: string): string;
+/**
+ * Validates if a string is a valid URL
+ *
+ * @param {string} str - The string to validate
+ * @returns {boolean} True if the string is a valid URL, false otherwise
+ * @example
+ * ```typescript
+ * const isValid = isValidUrl('https://example.com');
+ * // Returns: true
+ * ```
+ */
+export declare function isValidUrl(str: string): boolean;
+/**
+ * Sanitizes a file name by replacing invalid characters with underscores
+ *
+ * @param {string} fileName - The file name to sanitize
+ * @returns {string} The sanitized file name
+ * @example
+ * ```typescript
+ * const safe = sanitizeFileName('My Document!.pdf');
+ * // Returns: 'My_Document_.pdf'
+ * ```
+ */
+export declare function sanitizeFileName(fileName: string): string;
+/**
+ * Creates a debounced version of a function that delays execution
+ *
+ * @param {T} func - The function to debounce
+ * @param {number} wait - The delay in milliseconds
+ * @returns {Function} The debounced function
+ * @example
+ * ```typescript
+ * const debouncedSave = debounce(saveDocument, 300);
+ * debouncedSave(content); // Will only execute after 300ms of inactivity
+ * ```
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Performs a deep merge of objects, combining nested properties
+ *
+ * @param {T} target - The target object to merge into
+ * @param {...Partial<T>} sources - The source objects to merge from
+ * @returns {T} The merged object
+ * @example
+ * ```typescript
+ * const merged = deepMerge(
+ *   { a: { b: 1 } },
+ *   { a: { c: 2 } }
+ * );
+ * // Returns: { a: { b: 1, c: 2 } }
+ * ```
+ */
+export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CASrD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAIrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOtF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAMlC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAgB/F"}

package/dist/lib/index.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * @fileoverview Utility Library for Legal Markdown Processing
+ *
+ * This module provides essential utility functions for file operations,
+ * path handling, data manipulation, and common programming patterns used
+ * throughout the Legal Markdown processing system.
+ *
+ * Features:
+ * - File system operations with error handling
+ * - Path resolution and manipulation utilities
+ * - Data transformation and merging functions
+ * - Input validation and sanitization
+ * - Performance optimization utilities (debounce)
+ * - URL validation and file extension handling
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   readFileSync,
+ *   writeFileSync,
+ *   resolveFilePath,
+ *   deepMerge,
+ *   sanitizeFileName
+ * } from './lib';
+ *
+ * // Read a file safely
+ * const content = readFileSync('./document.md');
+ *
+ * // Resolve relative paths
+ * const fullPath = resolveFilePath('./docs', 'contract.md');
+ *
+ * // Merge configuration objects
+ * const config = deepMerge(defaultConfig, userConfig);
+ * ```
+ */
+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.ensureDirectoryExists = ensureDirectoryExists;
+exports.readFileSync = readFileSync;
+exports.writeFileSync = writeFileSync;
+exports.resolveFilePath = resolveFilePath;
+exports.getFileExtension = getFileExtension;
+exports.isValidUrl = isValidUrl;
+exports.sanitizeFileName = sanitizeFileName;
+exports.debounce = debounce;
+exports.deepMerge = deepMerge;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const _errors_1 = require("../errors/index.js");
+/**
+ * Ensures that a directory exists, creating it recursively if necessary
+ *
+ * @param {string} dirPath - The directory path to ensure exists
+ * @returns {void}
+ * @example
+ * ```typescript
+ * ensureDirectoryExists('./output/documents');
+ * ```
+ */
+function ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Reads a file synchronously with proper error handling
+ *
+ * @param {string} filePath - The path to the file to read
+ * @returns {string} The file content as UTF-8 string
+ * @throws {FileNotFoundError} When the file does not exist
+ * @throws {Error} For other file system errors
+ * @example
+ * ```typescript
+ * const content = readFileSync('./document.md');
+ * ```
+ */
+function readFileSync(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new _errors_1.FileNotFoundError(filePath);
+        }
+        throw error;
+    }
+}
+/**
+ * Writes content to a file synchronously, creating directories as needed
+ *
+ * @param {string} filePath - The path where the file will be written
+ * @param {string} content - The content to write to the file
+ * @returns {void}
+ * @example
+ * ```typescript
+ * writeFileSync('./output/document.md', processedContent);
+ * ```
+ */
+function writeFileSync(filePath, content) {
+    const dir = path.dirname(filePath);
+    ensureDirectoryExists(dir);
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+/**
+ * Resolves a file path relative to a base directory
+ *
+ * @param {string | undefined} basePath - The base directory path (defaults to cwd)
+ * @param {string} filePath - The file path to resolve
+ * @returns {string} The resolved absolute path
+ * @example
+ * ```typescript
+ * const fullPath = resolveFilePath('./docs', 'contract.md');
+ * // Returns: '/path/to/docs/contract.md'
+ * ```
+ */
+function resolveFilePath(basePath, filePath) {
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    const base = basePath || process.cwd();
+    return path.resolve(base, filePath);
+}
+/**
+ * Gets the file extension from a file path in lowercase
+ *
+ * @param {string} filePath - The file path to extract extension from
+ * @returns {string} The file extension in lowercase (including the dot)
+ * @example
+ * ```typescript
+ * const ext = getFileExtension('document.MD');
+ * // Returns: '.md'
+ * ```
+ */
+function getFileExtension(filePath) {
+    return path.extname(filePath).toLowerCase();
+}
+/**
+ * Validates if a string is a valid URL
+ *
+ * @param {string} str - The string to validate
+ * @returns {boolean} True if the string is a valid URL, false otherwise
+ * @example
+ * ```typescript
+ * const isValid = isValidUrl('https://example.com');
+ * // Returns: true
+ * ```
+ */
+function isValidUrl(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sanitizes a file name by replacing invalid characters with underscores
+ *
+ * @param {string} fileName - The file name to sanitize
+ * @returns {string} The sanitized file name
+ * @example
+ * ```typescript
+ * const safe = sanitizeFileName('My Document!.pdf');
+ * // Returns: 'My_Document_.pdf'
+ * ```
+ */
+function sanitizeFileName(fileName) {
+    return fileName.replace(/[^a-z0-9.-]/gi, '_');
+}
+/**
+ * Creates a debounced version of a function that delays execution
+ *
+ * @param {T} func - The function to debounce
+ * @param {number} wait - The delay in milliseconds
+ * @returns {Function} The debounced function
+ * @example
+ * ```typescript
+ * const debouncedSave = debounce(saveDocument, 300);
+ * debouncedSave(content); // Will only execute after 300ms of inactivity
+ * ```
+ */
+function debounce(func, wait) {
+    let timeout;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func(...args), wait);
+    };
+}
+/**
+ * Performs a deep merge of objects, combining nested properties
+ *
+ * @param {T} target - The target object to merge into
+ * @param {...Partial<T>} sources - The source objects to merge from
+ * @returns {T} The merged object
+ * @example
+ * ```typescript
+ * const merged = deepMerge(
+ *   { a: { b: 1 } },
+ *   { a: { c: 2 } }
+ * );
+ * // Returns: { a: { b: 1, c: 2 } }
+ * ```
+ */
+function deepMerge(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                deepMerge(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return deepMerge(target, ...sources);
+}
+/**
+ * Type guard to check if an item is a plain object
+ *
+ * @param {any} item - The item to check
+ * @returns {boolean} True if the item is a plain object, false otherwise
+ */
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

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

package/dist/parsers/content-detector.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview Content Detection Module for Legal Markdown Processing
+ *
+ * This module provides intelligent content type detection for various document
+ * formats including reStructuredText (RST) and LaTeX. It uses pattern matching
+ * and heuristics to determine if content requires specific parsers for conversion
+ * to Legal Markdown format.
+ *
+ * Features:
+ * - reStructuredText format detection with pattern-based analysis
+ * - LaTeX document format detection with command recognition
+ * - YAML frontmatter awareness to avoid false positives
+ * - Robust pattern matching with configurable thresholds
+ * - Support for various RST directives and syntax elements
+ * - LaTeX command and environment detection
+ *
+ * @example
+ * ```typescript
+ * import { ContentDetector } from './content-detector';
+ *
+ * // Detect RST content
+ * const isRst = ContentDetector.needsRstParser(content);
+ * if (isRst) {
+ *   content = await convertRstToLegalMarkdown(content);
+ * }
+ *
+ * // Detect LaTeX content
+ * const isLatex = ContentDetector.needsLatexParser(content);
+ * if (isLatex) {
+ *   content = await convertLatexToLegalMarkdown(content);
+ * }
+ * ```
+ */
+/**
+ * Content detection utility class for identifying document formats
+ *
+ * Provides static methods to detect different document formats using pattern
+ * matching and content analysis. Designed to prevent unnecessary processing
+ * of content that doesn't require specific parsers.
+ *
+ * @class ContentDetector
+ * @example
+ * ```typescript
+ * import { ContentDetector } from './content-detector';
+ *
+ * // Check if content needs RST processing
+ * if (ContentDetector.needsRstParser(content)) {
+ *   content = await processRstContent(content);
+ * }
+ *
+ * // Check if content needs LaTeX processing
+ * if (ContentDetector.needsLatexParser(content)) {
+ *   content = await processLatexContent(content);
+ * }
+ * ```
+ */
+export declare class ContentDetector {
+    /**
+     * Detects if content requires reStructuredText parsing
+     *
+     * Uses pattern matching to identify RST-specific syntax elements including
+     * directives, header underlines, reference links, code blocks, and other
+     * RST constructs. Avoids false positives with YAML frontmatter content.
+     *
+     * @static
+     * @param {string} content - The content to analyze for RST patterns
+     * @returns {boolean} True if content appears to be reStructuredText, false otherwise
+     * @example
+     * ```typescript
+     * const rstContent = `
+     * Introduction
+     * ============
+     *
+     * This is a sample RST document.
+     *
+     * .. note::
+     *    This is an RST directive.
+     * `;
+     *
+     * const isRst = ContentDetector.needsRstParser(rstContent);
+     * console.log(isRst); // true
+     * ```
+     */
+    static needsRstParser(content: string): boolean;
+    /**
+     * Detects if content requires LaTeX parsing
+     *
+     * Uses pattern matching to identify LaTeX-specific commands, environments,
+     * and syntax elements including document classes, sections, text formatting
+     * commands, and environments. Requires multiple pattern matches to avoid
+     * false positives.
+     *
+     * @static
+     * @param {string} content - The content to analyze for LaTeX patterns
+     * @returns {boolean} True if content appears to be LaTeX, false otherwise
+     * @example
+     * ```typescript
+     * const latexContent = `
+     * \\documentclass{article}
+     * \\begin{document}
+     * \\section{Introduction}
+     * This is \\textbf{bold} text in LaTeX.
+     * \\end{document}
+     * `;
+     *
+     * const isLatex = ContentDetector.needsLatexParser(latexContent);
+     * console.log(isLatex); // true
+     * ```
+     */
+    static needsLatexParser(content: string): boolean;
+    /**
+     * Detects if content requires Pandoc processing
+     *
+     * This is a convenience method that combines RST and LaTeX detection to
+     * determine if content needs any form of Pandoc processing for conversion
+     * to Legal Markdown format.
+     *
+     * @static
+     * @param {string} content - The content to analyze for format patterns
+     * @returns {boolean} True if content needs Pandoc processing, false otherwise
+     * @example
+     * ```typescript
+     * const needsProcessing = ContentDetector.needsPandoc(content);
+     * if (needsProcessing) {
+     *   content = await processThroughPandoc(content);
+     * }
+     * ```
+     */
+    static needsPandoc(content: string): boolean;
+}
+//# sourceMappingURL=content-detector.d.ts.map

package/dist/parsers/content-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-detector.d.ts","sourceRoot":"","sources":["../../src/parsers/content-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IA6C/C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAoDjD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;CAG7C"}