peasy-document 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peasy Tools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,282 @@
+# peasy-document
+
+[![npm](https://img.shields.io/npm/v/peasy-document)](https://www.npmjs.com/package/peasy-document)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)](https://www.npmjs.com/package/peasy-document)
+
+Pure TypeScript document conversion library for Markdown, HTML, CSV, JSON, and YAML transformations. Convert between 6 document formats with 10 conversion functions and frozen result objects -- all with zero runtime dependencies. Every conversion uses pure string processing, making it lightweight and fast for any JavaScript or TypeScript project.
+
+Part of the [Peasy Tools](https://peasytools.com) developer tools ecosystem.
+
+## Table of Contents
+
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What You Can Do](#what-you-can-do)
+  - [Markdown Conversion](#markdown-conversion)
+  - [HTML Processing](#html-processing)
+  - [CSV and JSON Conversion](#csv-and-json-conversion)
+  - [YAML Generation](#yaml-generation)
+  - [Table Formatting](#table-formatting)
+- [TypeScript Types](#typescript-types)
+- [API Reference](#api-reference)
+- [Also Available for Python](#also-available-for-python)
+- [Peasy Developer Tools](#peasy-developer-tools)
+- [License](#license)
+
+## Install
+
+```bash
+npm install peasy-document
+```
+
+Zero runtime dependencies. Works in Node.js, Deno, Bun, and modern bundlers.
+
+## Quick Start
+
+```typescript
+import { markdownToHtml, csvToJson, htmlToText } from "peasy-document";
+
+// Convert Markdown to HTML with headings, bold, italic, code blocks, and lists
+const result = markdownToHtml("# Hello World\n\nThis is **bold** text.");
+console.log(result.content);
+// <h1>Hello World</h1>
+// <p>This is <strong>bold</strong> text.</p>
+
+// Convert CSV data to JSON array of objects
+const json = csvToJson("name,age\nAlice,30\nBob,25");
+console.log(json.content);
+// [{"name": "Alice", "age": "30"}, {"name": "Bob", "age": "25"}]
+
+// Strip HTML to plain text with entity decoding
+const text = htmlToText("<h1>Title</h1><p>Hello &amp; welcome.</p>");
+console.log(text.content);
+// Title
+// Hello & welcome.
+```
+
+All functions return a `ConversionResult` with metadata:
+
+```typescript
+const result = markdownToHtml("# Hello");
+console.log(result.sourceFormat);  // "markdown"
+console.log(result.targetFormat);  // "html"
+console.log(result.sourceSize);    // 7 (bytes)
+console.log(result.targetSize);    // 14 (bytes)
+```
+
+## What You Can Do
+
+### Markdown Conversion
+
+Convert Markdown to HTML using a built-in pure TypeScript parser. Supports headings (h1-h6), bold, italic, inline code, fenced code blocks with language hints, links, images, unordered and ordered lists, blockquotes, horizontal rules, and paragraphs.
+
+```typescript
+import { markdownToHtml } from "peasy-document";
+
+// Full Markdown document with multiple elements
+const result = markdownToHtml(`
+# API Documentation
+
+| Feature | Status |
+|---------|--------|
+| Auth    | Done   |
+
+\`\`\`typescript
+const api = new Client({ key: "abc" });
+\`\`\`
+
+- First item
+- Second item
+
+> Important note about the API
+`);
+
+console.log(result.content);
+// <h1>API Documentation</h1>
+// <pre><code class="language-typescript">...</code></pre>
+// <ul><li>First item</li>...</ul>
+// <blockquote><p>Important note about the API</p></blockquote>
+```
+
+### HTML Processing
+
+Extract plain text from HTML documents, convert HTML to Markdown, or turn plain text into HTML paragraphs.
+
+```typescript
+import { htmlToText, htmlToMarkdown, textToHtml } from "peasy-document";
+
+// Strip all HTML tags and decode entities
+const text = htmlToText(`
+<html><body>
+  <h1>Welcome</h1>
+  <p>This is a <strong>formatted</strong> document with &amp; entities.</p>
+  <script>alert('ignored')</script>
+</body></html>
+`);
+console.log(text.content);
+// Welcome
+// This is a formatted document with & entities.
+
+// Convert HTML back to Markdown (handles h1-h6, a, strong, em, lists, code, pre, img)
+const md = htmlToMarkdown(`
+<h1>Document</h1>
+<p>Visit <a href="https://example.com">our site</a> for <strong>more info</strong>.</p>
+<ul><li>First</li><li>Second</li></ul>
+`);
+console.log(md.content);
+// # Document
+// Visit [our site](https://example.com) for **more info**.
+// - First
+// - Second
+
+// Convert plain text to HTML paragraphs
+const html = textToHtml("First paragraph.\n\nSecond paragraph.\nWith a line break.");
+console.log(html.content);
+// <p>First paragraph.</p>
+// <p>Second paragraph.<br>With a line break.</p>
+```
+
+### CSV and JSON Conversion
+
+Transform between CSV and JSON formats with proper handling of quoted fields, commas inside values, escaped quotes, and custom delimiters. Roundtrip-safe.
+
+```typescript
+import { csvToJson, jsonToCsv } from "peasy-document";
+
+// CSV to JSON array of objects
+const json = csvToJson("name,role,team\nAlice,Engineer,Backend\nBob,Designer,Frontend");
+console.log(json.content);
+// [
+//   {"name": "Alice", "role": "Engineer", "team": "Backend"},
+//   {"name": "Bob", "role": "Designer", "team": "Frontend"}
+// ]
+
+// JSON back to CSV
+const csv = jsonToCsv(json.content);
+console.log(csv.content);
+// name,role,team
+// Alice,Engineer,Backend
+// Bob,Designer,Frontend
+
+// Tab-separated values
+const tsv = csvToJson("name\tage\nAlice\t30", "\t");
+```
+
+### YAML Generation
+
+Convert JSON to YAML-like format without any external YAML library. Handles nested objects, arrays, strings, numbers, booleans, and null.
+
+```typescript
+import { jsonToYaml } from "peasy-document";
+
+const result = jsonToYaml(JSON.stringify({
+  server: { host: "localhost", port: 8080 },
+  features: ["auth", "logging"],
+  debug: true,
+  cache: null,
+}));
+console.log(result.content);
+// server:
+//   host: localhost
+//   port: 8080
+// features:
+//   - auth
+//   - logging
+// debug: true
+// cache: null
+```
+
+### Table Formatting
+
+Parse CSV into structured table data, or render it directly as Markdown or HTML tables.
+
+```typescript
+import { csvToTable, csvToMarkdown, csvToHtml } from "peasy-document";
+
+// Parse into structured TableData
+const table = csvToTable("Name,Age,City\nAlice,30,NYC\nBob,25,LA");
+console.log(table.headers);       // ["Name", "Age", "City"]
+console.log(table.rowCount);      // 2
+console.log(table.columnCount);   // 3
+console.log(table.rows[0]);       // ["Alice", "30", "NYC"]
+
+// Render as Markdown table with aligned columns
+const md = csvToMarkdown("Name,Age,City\nAlice,30,NYC\nBob,25,LA");
+console.log(md.content);
+// | Name  | Age | City |
+// | ----- | --- | ---- |
+// | Alice | 30  | NYC  |
+// | Bob   | 25  | LA   |
+
+// Render as HTML table with thead/tbody structure
+const html = csvToHtml("Name,Age\nAlice,30");
+console.log(html.content);
+// <table>
+//   <thead>
+//     <tr><th>Name</th><th>Age</th></tr>
+//   </thead>
+//   <tbody>
+//     <tr><td>Alice</td><td>30</td></tr>
+//   </tbody>
+// </table>
+```
+
+## TypeScript Types
+
+```typescript
+interface ConversionResult {
+  content: string;      // The converted content
+  sourceFormat: string;  // e.g. "markdown", "html", "csv", "json", "text"
+  targetFormat: string;  // e.g. "html", "text", "json", "csv", "yaml", "markdown"
+  sourceSize: number;    // Byte size of source (UTF-8)
+  targetSize: number;    // Byte size of output (UTF-8)
+}
+
+interface TableData {
+  headers: string[];     // Column headers from first row
+  rows: string[][];      // Data rows
+  rowCount: number;      // Number of data rows
+  columnCount: number;   // Number of columns
+}
+```
+
+## API Reference
+
+| Function | Input | Output | Description |
+|----------|-------|--------|-------------|
+| `markdownToHtml(source)` | Markdown | HTML | Headings, bold, italic, code, lists, links, images, blockquotes |
+| `htmlToText(source)` | HTML | Plain text | Strip tags, decode entities, normalize whitespace |
+| `htmlToMarkdown(source)` | HTML | Markdown | h1-h6, a, strong, em, lists, code, pre, img, blockquote |
+| `textToHtml(source)` | Plain text | HTML | Paragraphs to `<p>` tags, newlines to `<br>` |
+| `csvToJson(source, delimiter?)` | CSV | JSON | First row as headers, quoted field support |
+| `jsonToCsv(source)` | JSON | CSV | All unique keys as headers, nested values stringified |
+| `csvToTable(source, delimiter?)` | CSV | `TableData` | Structured headers, rows, and counts |
+| `csvToMarkdown(source, delimiter?)` | CSV | Markdown | Pipe-separated table with alignment row |
+| `csvToHtml(source, delimiter?)` | CSV | HTML | `<table>` with `<thead>` and `<tbody>` |
+| `jsonToYaml(source)` | JSON | YAML | Objects, arrays, primitives, null handling |
+
+## Also Available for Python
+
+```bash
+pip install peasy-document
+```
+
+The Python version provides the same 10 conversion functions with frozen dataclass results. See [peasy-document on PyPI](https://pypi.org/project/peasy-document/).
+
+## Peasy Developer Tools
+
+| Package | PyPI | npm | Description |
+|---------|------|-----|-------------|
+| **peasy-document** | [PyPI](https://pypi.org/project/peasy-document/) | [npm](https://www.npmjs.com/package/peasy-document) | Document conversion -- Markdown, HTML, CSV, JSON, YAML |
+| peasy-pdf | [PyPI](https://pypi.org/project/peasy-pdf/) | -- | PDF manipulation and conversion |
+| peasy-image | [PyPI](https://pypi.org/project/peasy-image/) | -- | Image format conversion and optimization |
+| peasytext | [PyPI](https://pypi.org/project/peasytext/) | [npm](https://www.npmjs.com/package/peasytext) | Text analysis and transformation |
+| peasy-css | [PyPI](https://pypi.org/project/peasy-css/) | [npm](https://www.npmjs.com/package/peasy-css) | CSS minification and processing |
+| peasy-compress | [PyPI](https://pypi.org/project/peasy-compress/) | [npm](https://www.npmjs.com/package/peasy-compress) | File compression utilities |
+| peasy-convert | [PyPI](https://pypi.org/project/peasy-convert/) | -- | Unified CLI for all Peasy tools |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Result of a document format conversion.
+ *
+ * All conversion functions return this interface with the converted content
+ * and metadata about the source/target formats and sizes (in bytes).
+ */
+interface ConversionResult {
+    /** The converted content string. */
+    content: string;
+    /** Source format identifier (e.g. "markdown", "html", "csv", "json", "text"). */
+    sourceFormat: string;
+    /** Target format identifier (e.g. "html", "text", "json", "csv", "yaml", "markdown"). */
+    targetFormat: string;
+    /** Byte size of the source input (UTF-8 encoded). */
+    sourceSize: number;
+    /** Byte size of the converted output (UTF-8 encoded). */
+    targetSize: number;
+}
+/**
+ * Structured table data parsed from CSV or similar tabular sources.
+ */
+interface TableData {
+    /** Column header names from the first row. */
+    headers: string[];
+    /** Data rows (each row is an array of cell values). */
+    rows: string[][];
+    /** Number of data rows (excluding the header). */
+    rowCount: number;
+    /** Number of columns. */
+    columnCount: number;
+}
+
+/**
+ * Document conversion engine — pure TypeScript functions for Markdown, HTML,
+ * CSV, JSON, and YAML transformations.
+ *
+ * Zero runtime dependencies. All conversions use string processing only.
+ */
+
+/**
+ * Convert Markdown to HTML.
+ *
+ * Supports headings (#-######), bold, italic, inline code, fenced code blocks,
+ * links, images, unordered lists (- or *), ordered lists (1.), blockquotes (>),
+ * horizontal rules (---/***), and paragraphs.
+ */
+declare function markdownToHtml(source: string): ConversionResult;
+/**
+ * Strip all HTML tags and decode entities to produce plain text.
+ *
+ * Removes script/style contents. Normalizes whitespace.
+ */
+declare function htmlToText(source: string): ConversionResult;
+/**
+ * Convert CSV to a JSON array of objects.
+ *
+ * The first row is used as headers (object keys). Handles quoted fields,
+ * escaped quotes, and custom delimiters.
+ */
+declare function csvToJson(source: string, delimiter?: string): ConversionResult;
+/**
+ * Convert a JSON array of objects to CSV.
+ *
+ * Extracts all unique keys as headers. Nested values are JSON-stringified.
+ */
+declare function jsonToCsv(source: string): ConversionResult;
+/**
+ * Parse CSV into structured TableData with headers, rows, and counts.
+ */
+declare function csvToTable(source: string, delimiter?: string): TableData;
+/**
+ * Convert CSV to a Markdown table with pipe separators and alignment row.
+ */
+declare function csvToMarkdown(source: string, delimiter?: string): ConversionResult;
+/**
+ * Convert CSV to an HTML table with proper thead/tbody structure.
+ */
+declare function csvToHtml(source: string, delimiter?: string): ConversionResult;
+/**
+ * Convert a JSON string to YAML-like format.
+ *
+ * Handles objects, arrays, strings, numbers, booleans, and null.
+ * No external YAML library required.
+ */
+declare function jsonToYaml(source: string): ConversionResult;
+/**
+ * Convert plain text to HTML paragraphs.
+ *
+ * Splits on double newlines, wraps each paragraph in <p> tags.
+ * Single newlines within a paragraph become <br> tags.
+ * HTML entities in the source text are escaped.
+ */
+declare function textToHtml(source: string): ConversionResult;
+/**
+ * Convert basic HTML to Markdown.
+ *
+ * Handles: h1-h6, p, a, strong/b, em/i, ul/ol/li, code, pre, br, img, blockquote.
+ * Uses regex-based tag replacement.
+ */
+declare function htmlToMarkdown(source: string): ConversionResult;
+
+export { type ConversionResult, type TableData, csvToHtml, csvToJson, csvToMarkdown, csvToTable, htmlToMarkdown, htmlToText, jsonToCsv, jsonToYaml, markdownToHtml, textToHtml };

package/dist/index.js

@@ -0,0 +1,461 @@
+// src/engine.ts
+function byteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+function makeResult(content, sourceFormat, targetFormat, source) {
+  return {
+    content,
+    sourceFormat,
+    targetFormat,
+    sourceSize: byteLength(source),
+    targetSize: byteLength(content)
+  };
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function decodeEntities(s) {
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_match, code) => String.fromCharCode(Number(code))).replace(
+    /&#x([0-9a-fA-F]+);/g,
+    (_match, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+}
+function parseCsv(source, delimiter = ",") {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let inQuotes = false;
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < source.length && source[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === delimiter) {
+        row.push(field);
+        field = "";
+      } else if (ch === "\n" || ch === "\r" && source[i + 1] === "\n") {
+        row.push(field);
+        field = "";
+        rows.push(row);
+        row = [];
+        if (ch === "\r") i++;
+      } else if (ch === "\r") {
+        row.push(field);
+        field = "";
+        rows.push(row);
+        row = [];
+      } else {
+        field += ch;
+      }
+    }
+  }
+  if (field || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function processInline(text) {
+  text = text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  text = text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  text = text.replace(/__(.+?)__/g, "<strong>$1</strong>");
+  text = text.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, "<em>$1</em>");
+  text = text.replace(/`([^`]+)`/g, "<code>$1</code>");
+  return text;
+}
+function markdownToHtml(source) {
+  const lines = source.split("\n");
+  const htmlParts = [];
+  let inCodeBlock = false;
+  let codeBlockContent = "";
+  let codeBlockLang = "";
+  let inList = null;
+  let paragraphBuffer = [];
+  function flushParagraph() {
+    if (paragraphBuffer.length > 0) {
+      const content2 = paragraphBuffer.map(processInline).join("\n");
+      htmlParts.push(`<p>${content2}</p>`);
+      paragraphBuffer = [];
+    }
+  }
+  function closeList() {
+    if (inList) {
+      htmlParts.push(inList === "ul" ? "</ul>" : "</ol>");
+      inList = null;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        flushParagraph();
+        closeList();
+        inCodeBlock = true;
+        codeBlockLang = line.trimStart().slice(3).trim();
+        codeBlockContent = "";
+      } else {
+        const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
+        htmlParts.push(
+          `<pre><code${langAttr}>${escapeHtml(codeBlockContent.replace(/\n$/, ""))}</code></pre>`
+        );
+        inCodeBlock = false;
+        codeBlockContent = "";
+        codeBlockLang = "";
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockContent += (codeBlockContent ? "\n" : "") + line;
+      continue;
+    }
+    if (line.trim() === "") {
+      flushParagraph();
+      closeList();
+      continue;
+    }
+    if (/^(\s*[-*_]\s*){3,}$/.test(line)) {
+      flushParagraph();
+      closeList();
+      htmlParts.push("<hr>");
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flushParagraph();
+      closeList();
+      const level = headingMatch[1].length;
+      const text = processInline(headingMatch[2]);
+      htmlParts.push(`<h${level}>${text}</h${level}>`);
+      continue;
+    }
+    const bqMatch = line.match(/^>\s?(.*)$/);
+    if (bqMatch) {
+      flushParagraph();
+      closeList();
+      const content2 = processInline(bqMatch[1]);
+      htmlParts.push(`<blockquote><p>${content2}</p></blockquote>`);
+      continue;
+    }
+    const ulMatch = line.match(/^[\s]*[-*]\s+(.+)$/);
+    if (ulMatch) {
+      flushParagraph();
+      if (inList !== "ul") {
+        closeList();
+        htmlParts.push("<ul>");
+        inList = "ul";
+      }
+      htmlParts.push(`<li>${processInline(ulMatch[1])}</li>`);
+      continue;
+    }
+    const olMatch = line.match(/^[\s]*\d+\.\s+(.+)$/);
+    if (olMatch) {
+      flushParagraph();
+      if (inList !== "ol") {
+        closeList();
+        htmlParts.push("<ol>");
+        inList = "ol";
+      }
+      htmlParts.push(`<li>${processInline(olMatch[1])}</li>`);
+      continue;
+    }
+    paragraphBuffer.push(line);
+  }
+  if (inCodeBlock) {
+    const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
+    htmlParts.push(
+      `<pre><code${langAttr}>${escapeHtml(codeBlockContent)}</code></pre>`
+    );
+  }
+  flushParagraph();
+  closeList();
+  const content = htmlParts.join("\n");
+  return makeResult(content, "markdown", "html", source);
+}
+function htmlToText(source) {
+  let text = source;
+  text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+  text = text.replace(
+    /<\/?(?:p|div|br|h[1-6]|li|tr|blockquote|pre|hr)(?:\s[^>]*)?\/?>/gi,
+    "\n"
+  );
+  text = text.replace(/<[^>]+>/g, "");
+  text = decodeEntities(text);
+  const lines = text.split("\n").map((line) => line.replace(/\s+/g, " ").trim());
+  text = lines.join("\n");
+  while (text.includes("\n\n\n")) {
+    text = text.replace(/\n\n\n/g, "\n\n");
+  }
+  const content = text.trim();
+  return makeResult(content, "html", "text", source);
+}
+function csvToJson(source, delimiter = ",") {
+  const rows = parseCsv(source, delimiter);
+  if (rows.length === 0) {
+    return makeResult("[]", "csv", "json", source);
+  }
+  const headers = rows[0];
+  const dataRows = rows.slice(1);
+  const objects = dataRows.map((row) => {
+    const obj = {};
+    headers.forEach((header, i) => {
+      obj[header] = i < row.length ? row[i] : "";
+    });
+    return obj;
+  });
+  const content = JSON.stringify(objects, null, 2);
+  return makeResult(content, "csv", "json", source);
+}
+function quoteCsvField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return '"' + value.replace(/"/g, '""') + '"';
+  }
+  return value;
+}
+function jsonToCsv(source) {
+  const data = JSON.parse(source);
+  if (!Array.isArray(data) || data.length === 0) {
+    return makeResult("", "json", "csv", source);
+  }
+  const allKeys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of data) {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      for (const key of Object.keys(item)) {
+        if (!seen.has(key)) {
+          allKeys.push(key);
+          seen.add(key);
+        }
+      }
+    }
+  }
+  const lines = [];
+  lines.push(allKeys.map(quoteCsvField).join(","));
+  for (const item of data) {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      const record = item;
+      const row = allKeys.map((key) => {
+        const val = record[key];
+        if (val === null || val === void 0) return "";
+        if (typeof val === "object") return quoteCsvField(JSON.stringify(val));
+        return quoteCsvField(String(val));
+      });
+      lines.push(row.join(","));
+    }
+  }
+  const content = lines.join("\n");
+  return makeResult(content, "json", "csv", source);
+}
+function csvToTable(source, delimiter = ",") {
+  const rows = parseCsv(source, delimiter);
+  if (rows.length === 0) {
+    return { headers: [], rows: [], rowCount: 0, columnCount: 0 };
+  }
+  const headers = rows[0];
+  const dataRows = rows.slice(1);
+  return {
+    headers,
+    rows: dataRows,
+    rowCount: dataRows.length,
+    columnCount: headers.length
+  };
+}
+function csvToMarkdown(source, delimiter = ",") {
+  const table = csvToTable(source, delimiter);
+  if (table.headers.length === 0) {
+    return makeResult("", "csv", "markdown", source);
+  }
+  const widths = table.headers.map((h) => h.length);
+  for (const row of table.rows) {
+    for (let i = 0; i < row.length && i < widths.length; i++) {
+      widths[i] = Math.max(widths[i], row[i].length);
+    }
+  }
+  for (let i = 0; i < widths.length; i++) {
+    widths[i] = Math.max(widths[i], 3);
+  }
+  const headerCells = table.headers.map((h, i) => h.padEnd(widths[i]));
+  const headerLine = "| " + headerCells.join(" | ") + " |";
+  const sepCells = widths.map((w) => "-".repeat(w));
+  const sepLine = "| " + sepCells.join(" | ") + " |";
+  const dataLines = table.rows.map((row) => {
+    const cells = table.headers.map((_, i) => {
+      const value = i < row.length ? row[i] : "";
+      return value.padEnd(widths[i]);
+    });
+    return "| " + cells.join(" | ") + " |";
+  });
+  const content = [headerLine, sepLine, ...dataLines].join("\n");
+  return makeResult(content, "csv", "markdown", source);
+}
+function csvToHtml(source, delimiter = ",") {
+  const table = csvToTable(source, delimiter);
+  if (table.headers.length === 0) {
+    const content2 = "<table></table>";
+    return makeResult(content2, "csv", "html", source);
+  }
+  const lines = ["<table>", "  <thead>", "    <tr>"];
+  for (const h of table.headers) {
+    lines.push(`      <th>${escapeHtml(h)}</th>`);
+  }
+  lines.push("    </tr>", "  </thead>", "  <tbody>");
+  for (const row of table.rows) {
+    lines.push("    <tr>");
+    for (let i = 0; i < table.headers.length; i++) {
+      const value = i < row.length ? row[i] : "";
+      lines.push(`      <td>${escapeHtml(value)}</td>`);
+    }
+    lines.push("    </tr>");
+  }
+  lines.push("  </tbody>", "</table>");
+  const content = lines.join("\n");
+  return makeResult(content, "csv", "html", source);
+}
+function yamlScalar(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  const s = String(value);
+  if (/[:#\[\]{},"&*!|>']/.test(s) || /^(true|false|null|yes|no|on|off)$/i.test(s) || s === "") {
+    const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `"${escaped}"`;
+  }
+  return s;
+}
+function toYamlLines(obj, indent = 0) {
+  const prefix = "  ".repeat(indent);
+  const lines = [];
+  if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+    const record = obj;
+    for (const [key, value] of Object.entries(record)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        lines.push(`${prefix}${key}:`);
+        lines.push(...toYamlLines(value, indent + 1));
+      } else if (Array.isArray(value)) {
+        lines.push(`${prefix}${key}:`);
+        for (const item of value) {
+          if (item && typeof item === "object") {
+            lines.push(`${prefix}  -`);
+            lines.push(...toYamlLines(item, indent + 2));
+          } else {
+            lines.push(`${prefix}  - ${yamlScalar(item)}`);
+          }
+        }
+      } else {
+        lines.push(`${prefix}${key}: ${yamlScalar(value)}`);
+      }
+    }
+  } else if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (item && typeof item === "object") {
+        lines.push(`${prefix}-`);
+        lines.push(...toYamlLines(item, indent + 1));
+      } else {
+        lines.push(`${prefix}- ${yamlScalar(item)}`);
+      }
+    }
+  } else {
+    lines.push(`${prefix}${yamlScalar(obj)}`);
+  }
+  return lines;
+}
+function jsonToYaml(source) {
+  const data = JSON.parse(source);
+  const lines = toYamlLines(data);
+  const content = lines.join("\n");
+  return makeResult(content, "json", "yaml", source);
+}
+function textToHtml(source) {
+  if (!source.trim()) {
+    return makeResult("", "text", "html", source);
+  }
+  const paragraphs = source.split(/\n\n+/).map((p) => p.trim()).filter((p) => p);
+  const htmlParts = paragraphs.map((para) => {
+    const escaped = escapeHtml(para);
+    const withBreaks = escaped.replace(/\n/g, "<br>");
+    return `<p>${withBreaks}</p>`;
+  });
+  const content = htmlParts.join("\n");
+  return makeResult(content, "text", "html", source);
+}
+function htmlToMarkdown(source) {
+  let md = source;
+  md = md.replace(/<script[\s\S]*?<\/script>/gi, "");
+  md = md.replace(/<style[\s\S]*?<\/style>/gi, "");
+  md = md.replace(
+    /<pre[^>]*>\s*<code[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/gi,
+    (_match, content2) => "\n\n```\n" + decodeEntities(content2).trim() + "\n```\n\n"
+  );
+  md = md.replace(
+    /<pre[^>]*>([\s\S]*?)<\/pre>/gi,
+    (_match, content2) => "\n\n```\n" + decodeEntities(content2).trim() + "\n```\n\n"
+  );
+  md = md.replace(
+    /<img[^>]*\ssrc=["']([^"']+)["'][^>]*\salt=["']([^"']*?)["'][^>]*\/?>/gi,
+    (_match, src, alt) => `![${alt}](${src})`
+  );
+  md = md.replace(
+    /<img[^>]*\salt=["']([^"']*?)["'][^>]*\ssrc=["']([^"']+)["'][^>]*\/?>/gi,
+    (_match, alt, src) => `![${alt}](${src})`
+  );
+  md = md.replace(
+    /<img[^>]*\ssrc=["']([^"']+)["'][^>]*\/?>/gi,
+    (_match, src) => `![](${src})`
+  );
+  md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "\n# $1\n");
+  md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "\n## $1\n");
+  md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "\n### $1\n");
+  md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, "\n#### $1\n");
+  md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, "\n##### $1\n");
+  md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, "\n###### $1\n");
+  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_match, content2) => {
+    const clean = content2.replace(/<\/?p[^>]*>/gi, "").trim();
+    return "\n> " + clean + "\n";
+  });
+  md = md.replace(/<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi, "**$1**");
+  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, "*$1*");
+  md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`");
+  md = md.replace(
+    /<a[^>]*\shref=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi,
+    (_match, href, text) => `[${text}](${href})`
+  );
+  md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_match, content2) => {
+    return "- " + content2.replace(/<\/?[^>]+>/g, "").trim() + "\n";
+  });
+  md = md.replace(/<\/?(?:ul|ol)[^>]*>/gi, "\n");
+  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, "\n$1\n");
+  md = md.replace(/<br\s*\/?>/gi, "  \n");
+  md = md.replace(/<hr\s*\/?>/gi, "\n---\n");
+  md = md.replace(/<[^>]+>/g, "");
+  md = decodeEntities(md);
+  while (md.includes("\n\n\n")) {
+    md = md.replace(/\n\n\n/g, "\n\n");
+  }
+  const content = md.trim();
+  return makeResult(content, "html", "markdown", source);
+}
+export {
+  csvToHtml,
+  csvToJson,
+  csvToMarkdown,
+  csvToTable,
+  htmlToMarkdown,
+  htmlToText,
+  jsonToCsv,
+  jsonToYaml,
+  markdownToHtml,
+  textToHtml
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "peasy-document",
+  "version": "0.1.0",
+  "description": "Document conversion library — Markdown, HTML, CSV, JSON, YAML. Zero dependencies, TypeScript-first.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "document",
+    "markdown",
+    "html",
+    "csv",
+    "json",
+    "yaml",
+    "converter",
+    "peasy"
+  ],
+  "author": "Peasy Tools",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/peasytools/peasy-document-js.git"
+  },
+  "homepage": "https://peasytools.com",
+  "devDependencies": {
+    "tsup": "^8.0",
+    "typescript": "^5.7",
+    "vitest": "^3.0"
+  }
+}