@utilix-tech/sdk 0.1.0

package/dist/tools/text.cjs

@@ -0,0 +1,2224 @@
+'use strict';
+
+var marked = require('marked');
+
+// src/tools/text.ts
+var WORDS_PER_MINUTE = 200;
+function countWords(text) {
+  if (!text) {
+    return { words: 0, chars: 0, charsNoSpaces: 0, lines: 0, sentences: 0, paragraphs: 0, readingTimeSec: 0 };
+  }
+  const chars = text.length;
+  const charsNoSpaces = text.replace(/\s/g, "").length;
+  const lines = text.split("\n").length;
+  const words = text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0).length;
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length || (text.trim() ? 1 : 0);
+  const readingTimeSec = Math.ceil(words / WORDS_PER_MINUTE * 60);
+  return { words, chars, charsNoSpaces, lines, sentences, paragraphs, readingTimeSec };
+}
+function formatReadingTime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSec = seconds % 60;
+  return remainingSec > 0 ? `${minutes}m ${remainingSec}s` : `${minutes}m`;
+}
+var CASE_FORMATS = [
+  "camelCase",
+  "PascalCase",
+  "snake_case",
+  "kebab-case",
+  "SCREAMING_SNAKE",
+  "Title Case",
+  "lowercase",
+  "UPPERCASE",
+  "dot.case",
+  "path/case"
+];
+function tokenize(input) {
+  return input.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s\-_./\\]+/).map((w) => w.trim()).filter(Boolean);
+}
+function capitalize(word) {
+  if (!word) return "";
+  return word[0].toUpperCase() + word.slice(1).toLowerCase();
+}
+function convertCase(input, format) {
+  if (!input.trim()) return "";
+  const words = tokenize(input);
+  if (!words.length) return "";
+  switch (format) {
+    case "camelCase":
+      return words.map((w, i) => i === 0 ? w.toLowerCase() : capitalize(w)).join("");
+    case "PascalCase":
+      return words.map(capitalize).join("");
+    case "snake_case":
+      return words.map((w) => w.toLowerCase()).join("_");
+    case "kebab-case":
+      return words.map((w) => w.toLowerCase()).join("-");
+    case "SCREAMING_SNAKE":
+      return words.map((w) => w.toUpperCase()).join("_");
+    case "Title Case":
+      return words.map(capitalize).join(" ");
+    case "lowercase":
+      return words.join(" ").toLowerCase();
+    case "UPPERCASE":
+      return words.join(" ").toUpperCase();
+    case "dot.case":
+      return words.map((w) => w.toLowerCase()).join(".");
+    case "path/case":
+      return words.map((w) => w.toLowerCase()).join("/");
+  }
+}
+function convertAll(input) {
+  return Object.fromEntries(
+    CASE_FORMATS.map((f) => [f, convertCase(input, f)])
+  );
+}
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "eu",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint",
+  "occaecat",
+  "cupidatat",
+  "non",
+  "proident",
+  "sunt",
+  "culpa",
+  "qui",
+  "officia",
+  "deserunt",
+  "mollit",
+  "anim",
+  "id",
+  "est",
+  "laborum",
+  "curabitur",
+  "pretium",
+  "tincidunt",
+  "lacus",
+  "nunc",
+  "pulvinar",
+  "sapien",
+  "ligula",
+  "egestas",
+  "feugiat",
+  "viverra",
+  "nisl",
+  "ultrices",
+  "metus",
+  "malesuada",
+  "facilisis",
+  "venenatis",
+  "porttitor",
+  "quam",
+  "luctus",
+  "accumsan",
+  "tortor",
+  "posuere",
+  "ac",
+  "ut",
+  "consequat",
+  "semper",
+  "viverra",
+  "nam",
+  "libero",
+  "justo",
+  "laoreet",
+  "sit",
+  "amet",
+  "cursus",
+  "magna",
+  "ac",
+  "placerat"
+];
+var LOREM_CLASSIC = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
+function loremWord(index) {
+  return LOREM_WORDS[index % LOREM_WORDS.length];
+}
+function makeSentence(startIndex, length = 8) {
+  const count = length + startIndex % 4;
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    words.push(loremWord(startIndex + i));
+  }
+  const sentence = words[0].charAt(0).toUpperCase() + words[0].slice(1) + " " + words.slice(1).join(" ") + ".";
+  return { text: sentence, nextIndex: startIndex + count };
+}
+function makeParagraph(startIndex, sentenceCount2 = 4) {
+  const sentences = [];
+  let idx = startIndex;
+  const count = sentenceCount2 + startIndex % 3;
+  for (let i = 0; i < count; i++) {
+    const { text, nextIndex } = makeSentence(idx, 8 + i % 4);
+    sentences.push(text);
+    idx = nextIndex;
+  }
+  return { text: sentences.join(" "), nextIndex: idx };
+}
+function generateWords(count, startClassic = true) {
+  if (count <= 0) return "";
+  const words = [];
+  if (startClassic) {
+    const classicWords = LOREM_CLASSIC.replace(/[^a-z\s]/gi, "").split(/\s+/);
+    words.push(...classicWords.slice(0, Math.min(count, classicWords.length)));
+  }
+  let idx = words.length;
+  while (words.length < count) {
+    words.push(loremWord(idx++));
+  }
+  return words.slice(0, count).join(" ");
+}
+function generateSentences(count) {
+  if (count <= 0) return "";
+  const sentences = [LOREM_CLASSIC];
+  let idx = 20;
+  while (sentences.length < count) {
+    const { text, nextIndex } = makeSentence(idx, 8);
+    sentences.push(text);
+    idx = nextIndex;
+  }
+  return sentences.slice(0, count).join(" ");
+}
+function generateParagraphs(count) {
+  if (count <= 0) return "";
+  const paragraphs = [LOREM_CLASSIC + " " + makeSentence(20, 10).text + " " + makeSentence(32, 9).text];
+  let idx = 44;
+  while (paragraphs.length < count) {
+    const { text, nextIndex } = makeParagraph(idx, 4);
+    paragraphs.push(text);
+    idx = nextIndex;
+  }
+  return paragraphs.slice(0, count).join("\n\n");
+}
+function generate(unit, count) {
+  switch (unit) {
+    case "words":
+      return generateWords(count);
+    case "sentences":
+      return generateSentences(count);
+    case "paragraphs":
+      return generateParagraphs(count);
+  }
+}
+function slugify(input, separator = "-") {
+  return input.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, separator).replace(new RegExp(`\\${separator}+`, "g"), separator).replace(new RegExp(`^\\${separator}|\\${separator}$`, "g"), "");
+}
+function slugifyAll(input) {
+  return {
+    "-": slugify(input, "-"),
+    "_": slugify(input, "_"),
+    ".": slugify(input, ".")
+  };
+}
+var ESCAPE_MODES = ["json", "javascript", "html", "url", "csv"];
+function escapeString(input, mode) {
+  switch (mode) {
+    case "json":
+      return input.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r").replace(/\0/g, "\\0");
+    case "javascript":
+      return input.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r").replace(/\0/g, "\\0").replace(/`/g, "\\`");
+    case "html":
+      return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+    case "url":
+      return encodeURIComponent(input);
+    case "csv": {
+      if (/[,\n"]/.test(input)) {
+        return '"' + input.replace(/"/g, '""') + '"';
+      }
+      return input;
+    }
+  }
+}
+function unescapeString(input, mode) {
+  switch (mode) {
+    case "json":
+      return input.replace(/\\0/g, "\0").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    case "javascript":
+      return input.replace(/\\0/g, "\0").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\n/g, "\n").replace(/\\`/g, "`").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    case "html":
+      return input.replace(/&#39;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+    case "url":
+      return decodeURIComponent(input);
+    case "csv": {
+      if (input.startsWith('"') && input.endsWith('"')) {
+        return input.slice(1, -1).replace(/""/g, '"');
+      }
+      return input;
+    }
+  }
+}
+function escapeAll(input) {
+  return {
+    json: escapeString(input, "json"),
+    javascript: escapeString(input, "javascript"),
+    html: escapeString(input, "html"),
+    url: escapeString(input, "url"),
+    csv: escapeString(input, "csv")
+  };
+}
+var LINE_OPS = [
+  "sort-asc",
+  "sort-desc",
+  "sort-natural",
+  "reverse",
+  "dedupe",
+  "dedupe-ci",
+  "shuffle",
+  "trim",
+  "remove-empty",
+  "number-lines"
+];
+function applyOp(input, op) {
+  if (input === "") return "";
+  const lines = input.split("\n");
+  switch (op) {
+    case "sort-asc":
+      return [...lines].sort((a, b) => a.localeCompare(b)).join("\n");
+    case "sort-desc":
+      return [...lines].sort((a, b) => b.localeCompare(a)).join("\n");
+    case "sort-natural":
+      return [...lines].sort((a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })).join("\n");
+    case "reverse":
+      return [...lines].reverse().join("\n");
+    case "dedupe": {
+      const seen = /* @__PURE__ */ new Set();
+      return lines.filter((line) => {
+        if (seen.has(line)) return false;
+        seen.add(line);
+        return true;
+      }).join("\n");
+    }
+    case "dedupe-ci": {
+      const seen = /* @__PURE__ */ new Set();
+      return lines.filter((line) => {
+        const key = line.toLowerCase();
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }).join("\n");
+    }
+    case "shuffle": {
+      const arr = [...lines];
+      for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+      }
+      return arr.join("\n");
+    }
+    case "trim":
+      return lines.map((line) => line.trim()).join("\n");
+    case "remove-empty":
+      return lines.filter((line) => line.trim() !== "").join("\n");
+    case "number-lines":
+      return lines.map((line, i) => `${i + 1}. ${line}`).join("\n");
+    default:
+      return input;
+  }
+}
+function applyOps(input, ops) {
+  return ops.reduce((current, op) => applyOp(current, op), input);
+}
+var DEFAULT_CONVERT_OPTIONS = {
+  headingStyle: "atx",
+  bulletStyle: "-",
+  codeBlockStyle: "fenced",
+  linkStyle: "inline"
+};
+function parseHtml(html) {
+  let i = 0;
+  function parseAttrs(attrStr) {
+    const attrs = {};
+    const re = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]*)))?/g;
+    let m;
+    while ((m = re.exec(attrStr)) !== null) {
+      if (m[1]) {
+        attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+      }
+    }
+    return attrs;
+  }
+  function parseNodes(endTag) {
+    const result = [];
+    while (i < html.length) {
+      if (html[i] === "<") {
+        if (html.startsWith("<!--", i)) {
+          const end = html.indexOf("-->", i);
+          i = end === -1 ? html.length : end + 3;
+          continue;
+        }
+        const tagMatch = html.slice(i).match(/^<\/([a-zA-Z][a-zA-Z0-9]*)\s*>/);
+        if (tagMatch) {
+          if (endTag && tagMatch[1].toLowerCase() === endTag.toLowerCase()) {
+            i += tagMatch[0].length;
+            return result;
+          }
+          i += tagMatch[0].length;
+          continue;
+        }
+        const selfClosingMatch = html.slice(i).match(/^<([a-zA-Z][a-zA-Z0-9]*)([^>]*)\/\s*>/);
+        if (selfClosingMatch) {
+          const tag = selfClosingMatch[1].toLowerCase();
+          const attrs = parseAttrs(selfClosingMatch[2]);
+          result.push({ type: "element", tag, attrs, children: [] });
+          i += selfClosingMatch[0].length;
+          continue;
+        }
+        const openMatch = html.slice(i).match(/^<([a-zA-Z][a-zA-Z0-9]*)([^>]*)>/);
+        if (openMatch) {
+          const tag = openMatch[1].toLowerCase();
+          const attrs = parseAttrs(openMatch[2]);
+          i += openMatch[0].length;
+          const voidTags = /* @__PURE__ */ new Set(["br", "hr", "img", "input", "meta", "link"]);
+          if (voidTags.has(tag)) {
+            result.push({ type: "element", tag, attrs, children: [] });
+            continue;
+          }
+          if (tag === "script" || tag === "style") {
+            const closeIdx = html.toLowerCase().indexOf(`</${tag}>`, i);
+            i = closeIdx === -1 ? html.length : closeIdx + tag.length + 3;
+            continue;
+          }
+          const children = parseNodes(tag);
+          result.push({ type: "element", tag, attrs, children });
+          continue;
+        }
+        result.push({ type: "text", text: "<" });
+        i++;
+      } else {
+        let j = i;
+        while (j < html.length && html[j] !== "<") j++;
+        const raw = html.slice(i, j);
+        result.push({ type: "text", text: decodeHtmlEntities(raw) });
+        i = j;
+      }
+    }
+    return result;
+  }
+  i = 0;
+  return parseNodes();
+}
+function decodeHtmlEntities(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10))).replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+function getTextContent(nodes) {
+  return nodes.map((n) => {
+    if (n.type === "text") return n.text ?? "";
+    return getTextContent(n.children ?? []);
+  }).join("");
+}
+function convertNodes(nodes, ctx, inline = false) {
+  return nodes.map((n) => convertNode(n, ctx, inline)).join("");
+}
+function convertNode(node, ctx, inline = false) {
+  if (node.type === "text") {
+    return node.text ?? "";
+  }
+  const tag = node.tag ?? "";
+  const children = node.children ?? [];
+  const attrs = node.attrs ?? {};
+  switch (tag) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6": {
+      const level = parseInt(tag[1], 10);
+      const text = convertNodes(children, ctx, true).trim();
+      if (ctx.options.headingStyle === "setext" && level <= 2) {
+        const underline = level === 1 ? "=".repeat(text.length) : "-".repeat(text.length);
+        return `
+
+${text}
+${underline}
+
+`;
+      }
+      const hashes = "#".repeat(level);
+      return `
+
+${hashes} ${text}
+
+`;
+    }
+    case "p": {
+      const content = convertNodes(children, ctx, true).trim();
+      if (!content) return "";
+      return `
+
+${content}
+
+`;
+    }
+    case "strong":
+    case "b": {
+      const content = convertNodes(children, ctx, true);
+      return `**${content}**`;
+    }
+    case "em":
+    case "i": {
+      const content = convertNodes(children, ctx, true);
+      return `*${content}*`;
+    }
+    case "del":
+    case "s": {
+      const content = convertNodes(children, ctx, true);
+      return `~~${content}~~`;
+    }
+    case "a": {
+      const href = attrs["href"] ?? "";
+      const text = convertNodes(children, ctx, true);
+      if (ctx.options.linkStyle === "reference") {
+        const existing = ctx.refs.find((r) => r.url === href);
+        const idx = existing ? existing.index : (() => {
+          const refIdx = ctx.refs.length + 1;
+          ctx.refs.push({ url: href, index: refIdx });
+          return refIdx;
+        })();
+        return `[${text}][${idx}]`;
+      }
+      return `[${text}](${href})`;
+    }
+    case "img": {
+      const src = attrs["src"] ?? "";
+      const alt = attrs["alt"] ?? "";
+      return `![${alt}](${src})`;
+    }
+    case "code": {
+      const text = getTextContent(children);
+      if (text.includes("`")) {
+        return `\`\`${text}\`\``;
+      }
+      return `\`${text}\``;
+    }
+    case "pre": {
+      const codeChild = children.find((c) => c.type === "element" && c.tag === "code");
+      const raw = codeChild ? getTextContent(codeChild.children ?? []) : getTextContent(children);
+      const lang = codeChild ? (codeChild.attrs?.["class"] ?? "").replace(/language-/, "").trim() : "";
+      const trimmed = raw.replace(/^\n/, "").replace(/\n$/, "");
+      if (ctx.options.codeBlockStyle === "indented") {
+        const indented = trimmed.split("\n").map((l) => `    ${l}`).join("\n");
+        return `
+
+${indented}
+
+`;
+      }
+      return `
+
+\`\`\`${lang}
+${trimmed}
+\`\`\`
+
+`;
+    }
+    case "blockquote": {
+      const inner = convertNodes(children, ctx).trim();
+      const quoted = inner.split("\n").map((l) => `> ${l}`).join("\n");
+      return `
+
+${quoted}
+
+`;
+    }
+    case "ul": {
+      ctx.listStack.push({ ordered: false, counter: 0 });
+      const items = convertNodes(children, ctx).replace(/\n$/, "");
+      ctx.listStack.pop();
+      const depth = ctx.listStack.length;
+      return depth === 0 ? `
+
+${items}
+
+` : `
+${items}`;
+    }
+    case "ol": {
+      ctx.listStack.push({ ordered: true, counter: 0 });
+      const items = convertNodes(children, ctx).replace(/\n$/, "");
+      ctx.listStack.pop();
+      const depth = ctx.listStack.length;
+      return depth === 0 ? `
+
+${items}
+
+` : `
+${items}`;
+    }
+    case "li": {
+      const current = ctx.listStack[ctx.listStack.length - 1];
+      const indent = "  ".repeat(Math.max(0, ctx.listStack.length - 1));
+      let prefix;
+      if (current?.ordered) {
+        current.counter++;
+        prefix = `${current.counter}.`;
+      } else {
+        prefix = ctx.options.bulletStyle;
+      }
+      const content = convertNodes(children, ctx, false).trim();
+      return `${indent}${prefix} ${content}
+`;
+    }
+    case "br": {
+      return "  \n";
+    }
+    case "hr": {
+      return "\n\n---\n\n";
+    }
+    case "table": {
+      return `
+
+${convertHtmlTable(children, ctx)}
+
+`;
+    }
+    case "thead":
+    case "tbody":
+    case "tfoot": {
+      return convertNodes(children, ctx);
+    }
+    case "tr": {
+      const cells = children.filter((c) => c.type === "element" && (c.tag === "th" || c.tag === "td")).map((c) => convertNodes(c.children ?? [], ctx, true).trim());
+      return `| ${cells.join(" | ")} |
+`;
+    }
+    case "th":
+    case "td": {
+      return convertNodes(children, ctx, true).trim();
+    }
+    case "div":
+    case "section":
+    case "article":
+    case "main":
+    case "header":
+    case "footer":
+    case "nav":
+    case "aside": {
+      return convertNodes(children, ctx);
+    }
+    case "span": {
+      return convertNodes(children, ctx, inline);
+    }
+    default: {
+      return convertNodes(children, ctx, inline);
+    }
+  }
+}
+function convertHtmlTable(nodes, ctx) {
+  const rows = [];
+  let headerRowIndex = -1;
+  function collectRows(nodes2, fromHead) {
+    for (const node of nodes2) {
+      if (node.type !== "element") continue;
+      if (node.tag === "thead") {
+        collectRows(node.children ?? [], true);
+      } else if (node.tag === "tbody" || node.tag === "tfoot") {
+        collectRows(node.children ?? [], false);
+      } else if (node.tag === "tr") {
+        const cells = (node.children ?? []).filter((c) => c.type === "element" && (c.tag === "th" || c.tag === "td")).map((c) => convertNodes(c.children ?? [], ctx, true).trim());
+        if (fromHead && headerRowIndex === -1) {
+          headerRowIndex = rows.length;
+        }
+        rows.push(cells);
+      }
+    }
+  }
+  collectRows(nodes, false);
+  if (rows.length === 0) return "";
+  const colCount = Math.max(...rows.map((r) => r.length));
+  const normalizeRow = (r) => {
+    while (r.length < colCount) r.push("");
+    return r;
+  };
+  const lines = [];
+  const effectiveHeaderIdx = headerRowIndex >= 0 ? headerRowIndex : 0;
+  rows.forEach((row, idx) => {
+    const normalized = normalizeRow([...row]);
+    lines.push(`| ${normalized.join(" | ")} |`);
+    if (idx === effectiveHeaderIdx) {
+      lines.push(`| ${normalized.map(() => "---").join(" | ")} |`);
+    }
+  });
+  return lines.join("\n");
+}
+function cleanupOutput(str) {
+  return str.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").replace(/\n+$/, "");
+}
+function htmlToMarkdown(html, options) {
+  if (!html || !html.trim()) return "";
+  const opts = { ...DEFAULT_CONVERT_OPTIONS, ...options };
+  const ctx = {
+    options: opts,
+    refs: [],
+    listStack: []
+  };
+  const nodes = parseHtml(html.trim());
+  const raw = convertNodes(nodes, ctx);
+  let result = cleanupOutput(raw);
+  if (opts.linkStyle === "reference" && ctx.refs.length > 0) {
+    const refBlock = ctx.refs.map((r) => `[${r.index}]: ${r.url}`).join("\n");
+    result = `${result}
+
+${refBlock}`;
+  }
+  return result;
+}
+function markdownToHtml(markdown) {
+  if (!markdown || !markdown.trim()) return "";
+  const lines = markdown.split("\n");
+  const output = [];
+  let i = 0;
+  function processInline(text) {
+    let result = text;
+    result = result.replace(/!\[([^\]]*)\]\(([^)]*)\)/g, '<img alt="$1" src="$2">');
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    result = result.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+    result = result.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+    result = result.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+    result = result.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+    result = result.replace(/_([^_]+)_/g, "<em>$1</em>");
+    result = result.replace(/`([^`]+)`/g, "<code>$1</code>");
+    return result;
+  }
+  while (i < lines.length) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^```(\w*)$/);
+    if (fenceMatch) {
+      const lang = fenceMatch[1];
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      const langAttr = lang ? ` class="language-${lang}"` : "";
+      output.push(`<pre><code${langAttr}>${codeLines.join("\n")}</code></pre>`);
+      continue;
+    }
+    const hrMatch = line.match(/^[-*_]{3,}\s*$/);
+    if (hrMatch && line.replace(/\s/g, "").split("").every((c) => c === line.trim()[0])) {
+      output.push("<hr>");
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const text = processInline(headingMatch[2].trim());
+      output.push(`<h${level}>${text}</h${level}>`);
+      i++;
+      continue;
+    }
+    if (i < lines.length - 1) {
+      const nextLine = lines[i + 1];
+      if (/^=+\s*$/.test(nextLine) && line.trim()) {
+        output.push(`<h1>${processInline(line.trim())}</h1>`);
+        i += 2;
+        continue;
+      }
+      if (/^-+\s*$/.test(nextLine) && line.trim() && !line.match(/^[-*+]\s/)) {
+        output.push(`<h2>${processInline(line.trim())}</h2>`);
+        i += 2;
+        continue;
+      }
+    }
+    if (line.startsWith(">")) {
+      const bqLines = [];
+      while (i < lines.length && lines[i].startsWith(">")) {
+        bqLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      const inner = markdownToHtml(bqLines.join("\n"));
+      output.push(`<blockquote>${inner}</blockquote>`);
+      continue;
+    }
+    if (/^(\s*)[-*+]\s/.test(line)) {
+      const ulLines = [];
+      while (i < lines.length && (/^(\s*)[-*+]\s/.test(lines[i]) || /^\s{2,}/.test(lines[i]))) {
+        ulLines.push(lines[i]);
+        i++;
+      }
+      output.push(parseMarkdownList(ulLines, false));
+      continue;
+    }
+    if (/^(\s*)\d+\.\s/.test(line)) {
+      const olLines = [];
+      while (i < lines.length && (/^(\s*)\d+\.\s/.test(lines[i]) || /^\s{2,}/.test(lines[i]))) {
+        olLines.push(lines[i]);
+        i++;
+      }
+      output.push(parseMarkdownList(olLines, true));
+      continue;
+    }
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    output.push(`<p>${processInline(line.trim())}</p>`);
+    i++;
+  }
+  return output.join("\n");
+}
+function parseMarkdownList(lines, ordered) {
+  const tag = ordered ? "ol" : "ul";
+  const items = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = ordered ? line.match(/^(\s*)\d+\.\s(.*)$/) : line.match(/^(\s*)[-*+]\s(.*)$/);
+    if (match) {
+      let content = match[2];
+      const subLines = [];
+      while (i + 1 < lines.length && (lines[i + 1].match(/^\s{2,}[-*+\d]/) || lines[i + 1].match(/^\s{4,}/))) {
+        i++;
+        subLines.push(lines[i].replace(/^  /, ""));
+      }
+      if (subLines.length > 0) {
+        const subOrdered = /^\s*\d+\./.test(subLines[0]);
+        content += parseMarkdownList(subLines, subOrdered);
+      }
+      items.push(`<li>${content}</li>`);
+    }
+  }
+  return `<${tag}>${items.join("")}</${tag}>`;
+}
+var ONES = [
+  "",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+var TENS = [
+  "",
+  "",
+  "twenty",
+  "thirty",
+  "forty",
+  "fifty",
+  "sixty",
+  "seventy",
+  "eighty",
+  "ninety"
+];
+var SCALES = [
+  "",
+  "thousand",
+  "million",
+  "billion",
+  "trillion",
+  "quadrillion"
+];
+function convertHundreds(n) {
+  if (n === 0) return "";
+  if (n < 20) return ONES[n];
+  if (n < 100) {
+    const ten = TENS[Math.floor(n / 10)];
+    const one = ONES[n % 10];
+    return one ? `${ten}-${one}` : ten;
+  }
+  const hundred = ONES[Math.floor(n / 100)];
+  const rest = convertHundreds(n % 100);
+  return rest ? `${hundred} hundred ${rest}` : `${hundred} hundred`;
+}
+function numberToWords(n) {
+  if (!isFinite(n) || isNaN(n)) {
+    return { error: "Input must be a finite number" };
+  }
+  const MAX = 999999999999999;
+  if (Math.abs(Math.trunc(n)) > MAX) {
+    return { error: `Number out of range (max \xB1${MAX})` };
+  }
+  if (n === 0) return "zero";
+  const isNegative = n < 0;
+  const absVal = Math.abs(n);
+  const decimalIndex = absVal.toString().indexOf(".");
+  let intPart = Math.trunc(absVal);
+  let decimalWords = "";
+  if (decimalIndex !== -1) {
+    const decStr = absVal.toString().slice(decimalIndex + 1);
+    const decDigits = decStr.split("").map(Number);
+    decimalWords = " point " + decDigits.map((d) => ONES[d] || "zero").join(" ");
+  }
+  if (intPart === 0 && decimalWords) {
+    const prefix2 = isNegative ? "negative " : "";
+    return `${prefix2}zero${decimalWords}`;
+  }
+  let result = "";
+  let scaleIndex = 0;
+  while (intPart > 0) {
+    const chunk = intPart % 1e3;
+    if (chunk !== 0) {
+      const chunkWords = convertHundreds(chunk);
+      const scale = SCALES[scaleIndex];
+      result = scale ? `${chunkWords} ${scale}${result ? " " + result : ""}` : chunkWords;
+    }
+    intPart = Math.floor(intPart / 1e3);
+    scaleIndex++;
+  }
+  const prefix = isNegative ? "negative " : "";
+  return `${prefix}${result}${decimalWords}`;
+}
+function numberToOrdinal(n) {
+  if (!Number.isInteger(n) || !isFinite(n)) {
+    return { error: "Input must be a finite integer" };
+  }
+  const abs = Math.abs(n);
+  const lastTwo = abs % 100;
+  const lastOne = abs % 10;
+  let suffix;
+  if (lastTwo >= 11 && lastTwo <= 13) {
+    suffix = "th";
+  } else if (lastOne === 1) {
+    suffix = "st";
+  } else if (lastOne === 2) {
+    suffix = "nd";
+  } else if (lastOne === 3) {
+    suffix = "rd";
+  } else {
+    suffix = "th";
+  }
+  return `${n}${suffix}`;
+}
+var ORDINAL_ONES = [
+  "",
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "eighth",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth",
+  "sixteenth",
+  "seventeenth",
+  "eighteenth",
+  "nineteenth"
+];
+var ORDINAL_TENS = [
+  "",
+  "",
+  "twentieth",
+  "thirtieth",
+  "fortieth",
+  "fiftieth",
+  "sixtieth",
+  "seventieth",
+  "eightieth",
+  "ninetieth"
+];
+function convertOrdinalHundreds(n) {
+  if (n < 20) return ORDINAL_ONES[n];
+  if (n < 100) {
+    const tenIndex = Math.floor(n / 10);
+    const one = n % 10;
+    if (one === 0) return ORDINAL_TENS[tenIndex];
+    return `${TENS[tenIndex]}-${ORDINAL_ONES[one]}`;
+  }
+  const hundred = ONES[Math.floor(n / 100)];
+  const rest = n % 100;
+  if (rest === 0) return `${hundred} hundredth`;
+  return `${hundred} hundred ${convertOrdinalHundreds(rest)}`;
+}
+function ordinalWords(n) {
+  if (!Number.isInteger(n) || !isFinite(n) || n < 0) {
+    return { error: "Input must be a non-negative finite integer" };
+  }
+  if (n === 0) return "zeroth";
+  const MAX = 999999999999999;
+  if (n > MAX) return { error: `Number out of range (max ${MAX})` };
+  const wordsResult = numberToWords(n);
+  if (typeof wordsResult !== "string") return wordsResult;
+  if (n <= 999) {
+    return convertOrdinalHundreds(n);
+  }
+  const lastChunk = n % 1e3;
+  if (lastChunk === 0) {
+    const parts = wordsResult.split(" ");
+    const lastWord = parts[parts.length - 1];
+    const ordinalScale = {
+      thousand: "thousandth",
+      million: "millionth",
+      billion: "billionth",
+      trillion: "trillionth",
+      quadrillion: "quadrillionth"
+    };
+    if (ordinalScale[lastWord]) {
+      parts[parts.length - 1] = ordinalScale[lastWord];
+      return parts.join(" ");
+    }
+    return wordsResult + "th";
+  }
+  const lastChunkCardinal = convertHundreds(lastChunk);
+  const lastChunkOrdinal = convertOrdinalHundreds(lastChunk);
+  const idx = wordsResult.lastIndexOf(lastChunkCardinal);
+  if (idx !== -1) {
+    return wordsResult.slice(0, idx) + lastChunkOrdinal;
+  }
+  return wordsResult + "th";
+}
+var ROMAN_VALUES = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function numberToRoman(n) {
+  if (!Number.isInteger(n) || n < 1 || n > 3999) {
+    return { error: "Input must be an integer between 1 and 3999" };
+  }
+  let result = "";
+  let remaining = n;
+  for (const [value, numeral] of ROMAN_VALUES) {
+    while (remaining >= value) {
+      result += numeral;
+      remaining -= value;
+    }
+  }
+  return result;
+}
+var ROMAN_MAP = {
+  I: 1,
+  V: 5,
+  X: 10,
+  L: 50,
+  C: 100,
+  D: 500,
+  M: 1e3
+};
+function romanToNumber(roman) {
+  if (!roman || !/^[IVXLCDM]+$/i.test(roman)) {
+    return { error: `Invalid Roman numeral: ${roman}` };
+  }
+  const upper = roman.toUpperCase();
+  let result = 0;
+  for (let i = 0; i < upper.length; i++) {
+    const curr = ROMAN_MAP[upper[i]];
+    const next = ROMAN_MAP[upper[i + 1]];
+    if (curr === void 0) return { error: `Invalid Roman numeral character: ${upper[i]}` };
+    if (next && curr < next) {
+      result -= curr;
+    } else {
+      result += curr;
+    }
+  }
+  const roundTrip = numberToRoman(result);
+  if (typeof roundTrip !== "string" || roundTrip !== upper) {
+    return { error: `Invalid Roman numeral: ${roman}` };
+  }
+  return result;
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "its",
+  "this",
+  "that",
+  "was",
+  "are",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "than",
+  "then",
+  "too",
+  "very",
+  "as",
+  "if",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "up",
+  "down",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "once",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "they",
+  "them",
+  "their",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "any",
+  "while"
+]);
+function sentenceCount(text) {
+  if (!text.trim()) return 0;
+  const matches = text.match(/[^.!?]*[.!?]+/g);
+  return matches ? matches.length : text.trim().length > 0 ? 1 : 0;
+}
+function syllableCount(word) {
+  const cleaned = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!cleaned) return 0;
+  if (cleaned.length <= 3) return 1;
+  let count = 0;
+  let prevWasVowel = false;
+  const vowels = /[aeiouy]/;
+  for (let i = 0; i < cleaned.length; i++) {
+    const isVowel = vowels.test(cleaned[i]);
+    if (isVowel && !prevWasVowel) {
+      count++;
+    }
+    prevWasVowel = isVowel;
+  }
+  if (cleaned.endsWith("e") && count > 1) {
+    count--;
+  }
+  if (cleaned.endsWith("le") && cleaned.length > 2 && !vowels.test(cleaned[cleaned.length - 3])) {
+    count++;
+  }
+  if ((cleaned.endsWith("es") || cleaned.endsWith("ed")) && count > 1) {
+    count--;
+  }
+  return Math.max(1, count);
+}
+function extractWords(text) {
+  return text.match(/\b[a-zA-Z']+\b/g) ?? [];
+}
+function analyzeText(text) {
+  const charCount = text.length;
+  const charCountNoSpaces = text.replace(/\s/g, "").length;
+  const words = extractWords(text);
+  const wordCount = words.length;
+  const sentences = sentenceCount(text);
+  const paragraphCount = text.trim() ? text.trim().split(/\n\s*\n+/).filter((p) => p.trim().length > 0).length : 0;
+  const lineCount = text.trim() ? text.split(/\n/).filter((l) => l.trim().length > 0).length : 0;
+  const totalWordLength = words.reduce((sum, w) => sum + w.replace(/'/g, "").length, 0);
+  const avgWordLength = wordCount > 0 ? Math.round(totalWordLength / wordCount * 100) / 100 : 0;
+  const avgWordsPerSentence = sentences > 0 ? Math.round(wordCount / sentences * 100) / 100 : 0;
+  const longestWord = words.reduce((longest, w) => w.length > longest.length ? w : longest, "");
+  const freq = {};
+  for (const w of words) {
+    const lower = w.toLowerCase();
+    freq[lower] = (freq[lower] ?? 0) + 1;
+  }
+  const mostFrequentWord = Object.entries(freq).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "";
+  const uniqueWordCount = Object.keys(freq).length;
+  const estimatedReadTime = Math.max(1, Math.ceil(wordCount / 200));
+  return {
+    charCount,
+    charCountNoSpaces,
+    wordCount,
+    sentenceCount: sentences,
+    paragraphCount,
+    lineCount,
+    avgWordLength,
+    avgWordsPerSentence,
+    longestWord,
+    mostFrequentWord,
+    uniqueWordCount,
+    estimatedReadTime
+  };
+}
+function readabilityScore(text) {
+  const words = extractWords(text);
+  const wordCount = words.length;
+  const sentences = sentenceCount(text);
+  if (sentences < 1 || wordCount < 1) {
+    return { error: "Requires at least 1 sentence and 1 word to compute" };
+  }
+  const totalSyllables = words.reduce((sum, w) => sum + syllableCount(w), 0);
+  const fleschReadingEase = Math.round(
+    (206.835 - 1.015 * (wordCount / sentences) - 84.6 * (totalSyllables / wordCount)) * 10
+  ) / 10;
+  const fleschKincaidGrade = Math.round(
+    (0.39 * (wordCount / sentences) + 11.8 * (totalSyllables / wordCount) - 15.59) * 10
+  ) / 10;
+  let readingLevel;
+  const grade = fleschKincaidGrade;
+  if (grade <= 5) readingLevel = "Elementary";
+  else if (grade <= 8) readingLevel = "Middle School";
+  else if (grade <= 12) readingLevel = "High School";
+  else if (grade <= 16) readingLevel = "College";
+  else readingLevel = "Expert";
+  return { fleschReadingEase, fleschKincaidGrade, readingLevel };
+}
+function wordFrequency(text, limit = 20) {
+  const words = extractWords(text);
+  const total = words.length;
+  if (total === 0) return [];
+  const freq = {};
+  for (const w of words) {
+    const lower = w.toLowerCase();
+    if (!STOP_WORDS.has(lower)) {
+      freq[lower] = (freq[lower] ?? 0) + 1;
+    }
+  }
+  return Object.entries(freq).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([word, count]) => ({
+    word,
+    count,
+    percent: Math.round(count / total * 1e4) / 100
+  }));
+}
+function lcsTextDiff(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const inLCS = Array.from({ length: m }, () => new Array(n).fill(false));
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      inLCS[i - 1][j - 1] = true;
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return inLCS;
+}
+function diffLines(left, right) {
+  const leftLines = left.split("\n");
+  const rightLines = right.split("\n");
+  const m = leftLines.length;
+  const n = rightLines.length;
+  const inLCS = lcsTextDiff(leftLines, rightLines);
+  const lines = [];
+  let li = 0, ri = 0;
+  let leftNum = 1, rightNum = 1;
+  let addedCount = 0, removedCount = 0, unchangedCount = 0;
+  while (li < m || ri < n) {
+    if (li < m && ri < n && inLCS[li]?.[ri]) {
+      lines.push({ type: "equal", text: leftLines[li], lineNumLeft: leftNum++, lineNumRight: rightNum++ });
+      unchangedCount++;
+      li++;
+      ri++;
+    } else if (li < m && (ri >= n || !inLCS[li]?.[ri])) {
+      const consumed = ri < n && inLCS[li] && Object.values(inLCS[li]).some(Boolean);
+      if (consumed) {
+        lines.push({ type: "removed", text: leftLines[li], lineNumLeft: leftNum++ });
+        removedCount++;
+        li++;
+      } else {
+        lines.push({ type: "removed", text: leftLines[li], lineNumLeft: leftNum++ });
+        removedCount++;
+        li++;
+      }
+    } else {
+      lines.push({ type: "added", text: rightLines[ri], lineNumRight: rightNum++ });
+      addedCount++;
+      ri++;
+    }
+  }
+  return { lines, addedCount, removedCount, unchangedCount };
+}
+function diffLinesSimple(left, right) {
+  const leftLines = left === "" ? [] : left.split("\n");
+  const rightLines = right === "" ? [] : right.split("\n");
+  const m = leftLines.length;
+  const n = rightLines.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = leftLines[i - 1] === rightLines[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+  const lines = [];
+  let addedCount = 0, removedCount = 0, unchangedCount = 0;
+  let leftNum = 1, rightNum = 1;
+  function backtrack(i, j) {
+    if (i === 0 && j === 0) return;
+    if (i > 0 && j > 0 && leftLines[i - 1] === rightLines[j - 1]) {
+      backtrack(i - 1, j - 1);
+      lines.push({ type: "equal", text: leftLines[i - 1], lineNumLeft: leftNum++, lineNumRight: rightNum++ });
+      unchangedCount++;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      backtrack(i, j - 1);
+      lines.push({ type: "added", text: rightLines[j - 1], lineNumRight: rightNum++ });
+      addedCount++;
+    } else {
+      backtrack(i - 1, j);
+      lines.push({ type: "removed", text: leftLines[i - 1], lineNumLeft: leftNum++ });
+      removedCount++;
+    }
+  }
+  backtrack(m, n);
+  return { lines, addedCount, removedCount, unchangedCount };
+}
+function parseDiff(unifiedDiff) {
+  if (typeof unifiedDiff !== "string") {
+    return { error: "Input must be a string" };
+  }
+  if (unifiedDiff.trim() === "") {
+    return {
+      files: [],
+      totalAdded: 0,
+      totalRemoved: 0,
+      stats: "0 files changed, 0 insertions(+), 0 deletions(-)"
+    };
+  }
+  const lines = unifiedDiff.split("\n");
+  const files = [];
+  let currentFile = null;
+  let currentHunk = null;
+  let oldLineNum = 0;
+  let newLineNum = 0;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (currentFile) {
+        if (currentHunk) {
+          currentFile.hunks.push(currentHunk);
+          currentHunk = null;
+        }
+        files.push(currentFile);
+      }
+      currentFile = {
+        oldPath: "",
+        newPath: "",
+        hunks: [],
+        added: 0,
+        removed: 0,
+        isBinary: false,
+        isNew: false,
+        isDeleted: false
+      };
+      continue;
+    }
+    if (line.startsWith("Binary files")) {
+      if (currentFile) {
+        currentFile.isBinary = true;
+      }
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      if (!currentFile) {
+        currentFile = {
+          oldPath: "",
+          newPath: "",
+          hunks: [],
+          added: 0,
+          removed: 0,
+          isBinary: false,
+          isNew: false,
+          isDeleted: false
+        };
+      }
+      const path = line.slice(4);
+      currentFile.oldPath = path;
+      if (path === "/dev/null") {
+        currentFile.isNew = true;
+      }
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      if (currentFile) {
+        const path = line.slice(4);
+        currentFile.newPath = path;
+        if (path === "/dev/null") {
+          currentFile.isDeleted = true;
+        }
+      }
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      if (currentFile) {
+        if (currentHunk) {
+          currentFile.hunks.push(currentHunk);
+        }
+        const match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (match) {
+          const oldStart = parseInt(match[1], 10);
+          const oldCount = match[2] !== void 0 ? parseInt(match[2], 10) : 1;
+          const newStart = parseInt(match[3], 10);
+          const newCount = match[4] !== void 0 ? parseInt(match[4], 10) : 1;
+          oldLineNum = oldStart;
+          newLineNum = newStart;
+          currentHunk = {
+            header: line,
+            lines: [],
+            oldStart,
+            oldCount,
+            newStart,
+            newCount
+          };
+        }
+      }
+      continue;
+    }
+    if (currentHunk && currentFile) {
+      if (line.startsWith("+")) {
+        const content = line.slice(1);
+        currentHunk.lines.push({
+          type: "added",
+          content,
+          lineNumber: { new: newLineNum }
+        });
+        currentFile.added++;
+        newLineNum++;
+      } else if (line.startsWith("-")) {
+        const content = line.slice(1);
+        currentHunk.lines.push({
+          type: "removed",
+          content,
+          lineNumber: { old: oldLineNum }
+        });
+        currentFile.removed++;
+        oldLineNum++;
+      } else if (line.startsWith(" ")) {
+        const content = line.slice(1);
+        currentHunk.lines.push({
+          type: "context",
+          content,
+          lineNumber: { old: oldLineNum, new: newLineNum }
+        });
+        oldLineNum++;
+        newLineNum++;
+      }
+    }
+  }
+  if (currentFile) {
+    if (currentHunk) {
+      currentFile.hunks.push(currentHunk);
+    }
+    files.push(currentFile);
+  }
+  const totalAdded = files.reduce((sum, f) => sum + f.added, 0);
+  const totalRemoved = files.reduce((sum, f) => sum + f.removed, 0);
+  const fileCount = files.length;
+  const filePart = `${fileCount} ${fileCount === 1 ? "file" : "files"} changed`;
+  const addPart = `${totalAdded} ${totalAdded === 1 ? "insertion" : "insertions"}(+)`;
+  const delPart = `${totalRemoved} ${totalRemoved === 1 ? "deletion" : "deletions"}(-)`;
+  const stats = `${filePart}, ${addPart}, ${delPart}`;
+  return { files, totalAdded, totalRemoved, stats };
+}
+function lcsDiffViewer(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+  return dp;
+}
+function backtrackDiff(dp, a, b) {
+  const result = [];
+  let i = a.length;
+  let j = b.length;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+      result.push({ type: "equal", line: a[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.push({ type: "insert", line: b[j - 1] });
+      j--;
+    } else {
+      result.push({ type: "delete", line: a[i - 1] });
+      i--;
+    }
+  }
+  return result.reverse();
+}
+function generateDiff(original, modified, filename = "file") {
+  const originalLines = original === "" ? [] : original.split("\n");
+  const modifiedLines = modified === "" ? [] : modified.split("\n");
+  const dp = lcsDiffViewer(originalLines, modifiedLines);
+  const ops = backtrackDiff(dp, originalLines, modifiedLines);
+  const CONTEXT = 3;
+  const changes = [];
+  ops.forEach((op, idx) => {
+    if (op.type !== "equal") {
+      changes.push(idx);
+    }
+  });
+  if (changes.length === 0) {
+    return "";
+  }
+  const hunks = [];
+  let hunkStart = Math.max(0, changes[0] - CONTEXT);
+  let hunkEnd = Math.min(ops.length - 1, changes[0] + CONTEXT);
+  for (let ci = 1; ci < changes.length; ci++) {
+    const changeIdx = changes[ci];
+    const contextStart = Math.max(0, changeIdx - CONTEXT);
+    if (contextStart <= hunkEnd + 1) {
+      hunkEnd = Math.min(ops.length - 1, changeIdx + CONTEXT);
+    } else {
+      hunks.push({ start: hunkStart, end: hunkEnd });
+      hunkStart = contextStart;
+      hunkEnd = Math.min(ops.length - 1, changeIdx + CONTEXT);
+    }
+  }
+  hunks.push({ start: hunkStart, end: hunkEnd });
+  const outputLines = [
+    `--- a/${filename}`,
+    `+++ b/${filename}`
+  ];
+  for (const hunk of hunks) {
+    let oldStart = 1;
+    let newStart = 1;
+    let oldCount = 0;
+    let newCount = 0;
+    let oldLineAt = 0;
+    let newLineAt = 0;
+    for (let i = 0; i < hunk.start; i++) {
+      if (ops[i].type === "equal" || ops[i].type === "delete") oldLineAt++;
+      if (ops[i].type === "equal" || ops[i].type === "insert") newLineAt++;
+    }
+    oldStart = oldLineAt + 1;
+    newStart = newLineAt + 1;
+    const hunkLines = [];
+    for (let i = hunk.start; i <= hunk.end; i++) {
+      const op = ops[i];
+      if (op.type === "equal") {
+        hunkLines.push(` ${op.line}`);
+        oldCount++;
+        newCount++;
+      } else if (op.type === "delete") {
+        hunkLines.push(`-${op.line}`);
+        oldCount++;
+      } else {
+        hunkLines.push(`+${op.line}`);
+        newCount++;
+      }
+    }
+    outputLines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+    outputLines.push(...hunkLines);
+  }
+  return outputLines.join("\n");
+}
+function diffStats(diff) {
+  return {
+    files: diff.files.length,
+    added: diff.totalAdded,
+    removed: diff.totalRemoved
+  };
+}
+function extractHeadings(markdown) {
+  const headings = [];
+  const lines = markdown.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6}) (.+)/);
+    if (match) {
+      headings.push({ level: match[1].length, text: match[2].trim() });
+    }
+  }
+  return headings;
+}
+function renderMarkdown(input) {
+  const html = marked.marked.parse(input);
+  const headings = extractHeadings(input);
+  const stripped = input.replace(/#{1,6} /g, "").replace(/[*_~`]/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<[^>]+>/g, "").trim();
+  const wordCount = stripped.length === 0 ? 0 : stripped.split(/\s+/).filter((w) => w.length > 0).length;
+  return { html, wordCount, headings };
+}
+function detectDelimiter(csv) {
+  const delimiters = [",", "	", ";", "|"];
+  const lines = csv.split("\n").filter((l) => l.trim() !== "").slice(0, 10);
+  if (lines.length === 0) return ",";
+  const counts = { ",": [], "	": [], ";": [], "|": [] };
+  for (const line of lines) {
+    for (const d of delimiters) {
+      const count = line.split(d).length - 1;
+      counts[d].push(count);
+    }
+  }
+  let bestDelimiter = ",";
+  let bestScore = -1;
+  for (const d of delimiters) {
+    const arr = counts[d];
+    if (arr.length === 0) continue;
+    const avg = arr.reduce((a, b) => a + b, 0) / arr.length;
+    if (avg === 0) continue;
+    const variance = arr.reduce((a, b) => a + Math.pow(b - avg, 2), 0) / arr.length;
+    const score = avg - variance;
+    if (score > bestScore) {
+      bestScore = score;
+      bestDelimiter = d;
+    }
+  }
+  return bestDelimiter;
+}
+function parseTableData(input, options) {
+  if (!input || input.trim() === "") return { error: "Input is empty" };
+  const delimiter = options?.delimiter ?? detectDelimiter(input);
+  const hasHeader = options?.hasHeader !== false;
+  const lines = input.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.trim() !== "");
+  if (lines.length === 0) return { error: "No data found" };
+  const allRows = lines.map((line) => line.split(delimiter));
+  const colCount = Math.max(...allRows.map((r) => r.length));
+  let headers;
+  let rows;
+  if (hasHeader) {
+    headers = allRows[0].map((h) => h.trim());
+    rows = allRows.slice(1);
+  } else {
+    headers = Array.from({ length: colCount }, (_, i) => `Column ${i + 1}`);
+    rows = allRows;
+  }
+  return {
+    headers,
+    rows,
+    delimiter,
+    rowCount: rows.length,
+    colCount
+  };
+}
+function escapeHtmlTable(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateHtmlTable(data, options) {
+  const classes = [];
+  if (options?.striped) classes.push("striped");
+  if (options?.sortable) classes.push("sortable");
+  const attrs = ["<table"];
+  if (options?.id) attrs.push(` id="${escapeHtmlTable(options.id)}"`);
+  if (options?.bordered) attrs.push(' border="1"');
+  if (classes.length > 0) attrs.push(` class="${classes.join(" ")}"`);
+  if (options?.sortable) attrs.push(" data-sortable");
+  attrs.push(">");
+  const parts = [attrs.join("")];
+  if (options?.caption) {
+    parts.push(`  <caption>${escapeHtmlTable(options.caption)}</caption>`);
+  }
+  parts.push("  <thead>");
+  parts.push("    <tr>");
+  for (const header of data.headers) {
+    parts.push(`      <th>${escapeHtmlTable(header)}</th>`);
+  }
+  parts.push("    </tr>");
+  parts.push("  </thead>");
+  parts.push("  <tbody>");
+  for (const row of data.rows) {
+    parts.push("    <tr>");
+    for (let i = 0; i < data.colCount; i++) {
+      const cell = row[i] ?? "";
+      parts.push(`      <td>${escapeHtmlTable(cell)}</td>`);
+    }
+    parts.push("    </tr>");
+  }
+  parts.push("  </tbody>");
+  parts.push("</table>");
+  return parts.join("\n");
+}
+function generateMarkdownTable(data) {
+  const lines = [];
+  const headerRow = "| " + data.headers.map((h) => h.trim()).join(" | ") + " |";
+  lines.push(headerRow);
+  const separatorRow = "| " + data.headers.map(() => "---").join(" | ") + " |";
+  lines.push(separatorRow);
+  for (const row of data.rows) {
+    const cells = Array.from({ length: data.colCount }, (_, i) => (row[i] ?? "").trim());
+    lines.push("| " + cells.join(" | ") + " |");
+  }
+  return lines.join("\n");
+}
+function csvToHtml(input, options) {
+  const result = parseTableData(input, options);
+  if (typeof result === "object" && "error" in result) return result;
+  return generateHtmlTable(result, options);
+}
+function csvToMarkdown(input, options) {
+  const result = parseTableData(input, options);
+  if (typeof result === "object" && "error" in result) return result;
+  return generateMarkdownTable(result);
+}
+var BLOCK_FONT = {
+  "A": ["\u2588\u2588\u2588\u2588\u2588", "\u2588   \u2588", "\u2588\u2588\u2588\u2588\u2588", "\u2588   \u2588", "\u2588   \u2588"],
+  "B": ["\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588\u2588\u2588\u2588 "],
+  "C": [" \u2588\u2588\u2588\u2588", "\u2588    ", "\u2588    ", "\u2588    ", " \u2588\u2588\u2588\u2588"],
+  "D": ["\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", "\u2588\u2588\u2588\u2588 "],
+  "E": ["\u2588\u2588\u2588\u2588\u2588", "\u2588    ", "\u2588\u2588\u2588\u2588 ", "\u2588    ", "\u2588\u2588\u2588\u2588\u2588"],
+  "F": ["\u2588\u2588\u2588\u2588\u2588", "\u2588    ", "\u2588\u2588\u2588\u2588 ", "\u2588    ", "\u2588    "],
+  "G": [" \u2588\u2588\u2588\u2588", "\u2588    ", "\u2588  \u2588\u2588", "\u2588   \u2588", " \u2588\u2588\u2588\u2588"],
+  "H": ["\u2588   \u2588", "\u2588   \u2588", "\u2588\u2588\u2588\u2588\u2588", "\u2588   \u2588", "\u2588   \u2588"],
+  "I": ["\u2588\u2588\u2588\u2588\u2588", "  \u2588  ", "  \u2588  ", "  \u2588  ", "\u2588\u2588\u2588\u2588\u2588"],
+  "J": ["\u2588\u2588\u2588\u2588\u2588", "  \u2588  ", "  \u2588  ", "\u2588 \u2588  ", " \u2588\u2588  "],
+  "K": ["\u2588   \u2588", "\u2588  \u2588 ", "\u2588\u2588\u2588  ", "\u2588  \u2588 ", "\u2588   \u2588"],
+  "L": ["\u2588    ", "\u2588    ", "\u2588    ", "\u2588    ", "\u2588\u2588\u2588\u2588\u2588"],
+  "M": ["\u2588   \u2588", "\u2588\u2588 \u2588\u2588", "\u2588 \u2588 \u2588", "\u2588   \u2588", "\u2588   \u2588"],
+  "N": ["\u2588   \u2588", "\u2588\u2588  \u2588", "\u2588 \u2588 \u2588", "\u2588  \u2588\u2588", "\u2588   \u2588"],
+  "O": [" \u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", " \u2588\u2588\u2588 "],
+  "P": ["\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588\u2588\u2588\u2588 ", "\u2588    ", "\u2588    "],
+  "Q": [" \u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588   \u2588", "\u2588  \u2588\u2588", " \u2588\u2588\u2588\u2588"],
+  "R": ["\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", "\u2588\u2588\u2588\u2588 ", "\u2588  \u2588 ", "\u2588   \u2588"],
+  "S": [" \u2588\u2588\u2588\u2588", "\u2588    ", " \u2588\u2588\u2588 ", "    \u2588", "\u2588\u2588\u2588\u2588 "],
+  "T": ["\u2588\u2588\u2588\u2588\u2588", "  \u2588  ", "  \u2588  ", "  \u2588  ", "  \u2588  "],
+  "U": ["\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", " \u2588\u2588\u2588 "],
+  "V": ["\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", " \u2588 \u2588 ", "  \u2588  "],
+  "W": ["\u2588   \u2588", "\u2588   \u2588", "\u2588 \u2588 \u2588", "\u2588\u2588 \u2588\u2588", "\u2588   \u2588"],
+  "X": ["\u2588   \u2588", " \u2588 \u2588 ", "  \u2588  ", " \u2588 \u2588 ", "\u2588   \u2588"],
+  "Y": ["\u2588   \u2588", " \u2588 \u2588 ", "  \u2588  ", "  \u2588  ", "  \u2588  "],
+  "Z": ["\u2588\u2588\u2588\u2588\u2588", "   \u2588 ", "  \u2588  ", " \u2588   ", "\u2588\u2588\u2588\u2588\u2588"],
+  "0": [" \u2588\u2588\u2588 ", "\u2588  \u2588\u2588", "\u2588 \u2588 \u2588", "\u2588\u2588  \u2588", " \u2588\u2588\u2588 "],
+  "1": ["  \u2588  ", " \u2588\u2588  ", "  \u2588  ", "  \u2588  ", "\u2588\u2588\u2588\u2588\u2588"],
+  "2": [" \u2588\u2588\u2588 ", "\u2588   \u2588", "  \u2588\u2588 ", " \u2588   ", "\u2588\u2588\u2588\u2588\u2588"],
+  "3": ["\u2588\u2588\u2588\u2588 ", "    \u2588", " \u2588\u2588\u2588 ", "    \u2588", "\u2588\u2588\u2588\u2588 "],
+  "4": ["\u2588   \u2588", "\u2588   \u2588", "\u2588\u2588\u2588\u2588\u2588", "    \u2588", "    \u2588"],
+  "5": ["\u2588\u2588\u2588\u2588\u2588", "\u2588    ", "\u2588\u2588\u2588\u2588 ", "    \u2588", "\u2588\u2588\u2588\u2588 "],
+  "6": [" \u2588\u2588\u2588 ", "\u2588    ", "\u2588\u2588\u2588\u2588 ", "\u2588   \u2588", " \u2588\u2588\u2588 "],
+  "7": ["\u2588\u2588\u2588\u2588\u2588", "    \u2588", "   \u2588 ", "  \u2588  ", "  \u2588  "],
+  "8": [" \u2588\u2588\u2588 ", "\u2588   \u2588", " \u2588\u2588\u2588 ", "\u2588   \u2588", " \u2588\u2588\u2588 "],
+  "9": [" \u2588\u2588\u2588 ", "\u2588   \u2588", " \u2588\u2588\u2588\u2588", "    \u2588", " \u2588\u2588\u2588 "],
+  " ": ["     ", "     ", "     ", "     ", "     "],
+  "!": ["  \u2588  ", "  \u2588  ", "  \u2588  ", "     ", "  \u2588  "],
+  "?": [" \u2588\u2588\u2588 ", "    \u2588", "  \u2588\u2588 ", "     ", "  \u2588  "],
+  ".": ["     ", "     ", "     ", "     ", "  \u2588  "],
+  ",": ["     ", "     ", "     ", "  \u2588  ", " \u2588   "],
+  "-": ["     ", "     ", "\u2588\u2588\u2588\u2588\u2588", "     ", "     "],
+  ":": ["     ", "  \u2588  ", "     ", "  \u2588  ", "     "]
+};
+var BANNER_FONT = {
+  "A": [" /\\ ", "/--\\", "/  \\"],
+  "B": ["|-- ", "|-- ", "|__/"],
+  "C": [" /-", "|  ", " \\-"],
+  "D": ["|\\ ", "| \\", "|_/"],
+  "E": ["|--", "|- ", "|__"],
+  "F": ["|--", "|- ", "|  "],
+  "G": [" /-", "| -", " \\-"],
+  "H": ["| |", "|-|", "| |"],
+  "I": ["---", " | ", "---"],
+  "J": ["  |", "  |", "\\_/"],
+  "K": ["| /", "|-/", "| \\"],
+  "L": ["|  ", "|  ", "|__"],
+  "M": ["|\\/|", "|  |", "|  |"],
+  "N": ["|\\ |", "| \\|", "|  |"],
+  "O": [" _ ", "| |", " - "],
+  "P": ["|- ", "|- ", "|  "],
+  "Q": [" _ ", "|_|", " -\\"],
+  "R": ["|- ", "|-/", "| \\"],
+  "S": [" /-", " --", "__/"],
+  "T": ["---", " | ", " | "],
+  "U": ["| |", "| |", "\\_/"],
+  "V": ["\\  /", " \\/ ", "    "],
+  "W": ["|  |", "|/\\|", "|  |"],
+  "X": ["\\ /", " X ", "/ \\"],
+  "Y": ["\\/", " |", " |"],
+  "Z": ["--/", " / ", "/--"],
+  "0": [" 0 ", "|0|", " 0 "],
+  "1": ["/1 ", " 1 ", "_1_"],
+  "2": ["-2-", " 2/", "2--"],
+  "3": ["-3-", " 3 ", "-3-"],
+  "4": ["4 4", "444", "  4"],
+  "5": ["5--", "5- ", "--5"],
+  "6": [" 6 ", "6- ", " 6 "],
+  "7": ["77/", "  7", "  7"],
+  "8": ["888", "8 8", "888"],
+  "9": ["999", " 9 ", "  9"],
+  " ": ["   ", "   ", "   "],
+  "!": [" ! ", " ! ", " . "],
+  "?": ["-?-", " ? ", " . "],
+  ".": ["   ", "   ", " . "],
+  ",": ["   ", "   ", ",  "],
+  "-": ["   ", "---", "   "],
+  ":": [" : ", "   ", " : "]
+};
+var SMALL_FONT = {
+  "A": ["/-\\", "|_|"],
+  "B": ["|_)", "|_)"],
+  "C": ["/-", "\\_"],
+  "D": ["|\\ ", "|_/"],
+  "E": ["|-", "|_"],
+  "F": ["|-", "| "],
+  "G": ["/-", "\\_|"],
+  "H": ["|_|", "| |"],
+  "I": ["-|-", "-|-"],
+  "J": ["  |", "\\_|"],
+  "K": ["|/ ", "|\\ "],
+  "L": ["|  ", "|__"],
+  "M": ["|\\/|", "|  |"],
+  "N": ["|\\ ", "| \\"],
+  "O": ["(_)", "(_)"],
+  "P": ["|_)", "|  "],
+  "Q": ["(_)", "(_\\"],
+  "R": ["|_)", "| \\"],
+  "S": ["/_", "\\_"],
+  "T": ["-|-", " | "],
+  "U": ["| |", "\\_/"],
+  "V": ["\\/", " v "],
+  "W": ["| |", "|_|"],
+  "X": ["\\ /", " X "],
+  "Y": ["\\/", " | "],
+  "Z": ["_/", "/_ "],
+  "0": ["0", "0"],
+  "1": ["1", "1"],
+  "2": ["2", "2"],
+  "3": ["3", "3"],
+  "4": ["4", "4"],
+  "5": ["5", "5"],
+  "6": ["6", "6"],
+  "7": ["7", "7"],
+  "8": ["8", "8"],
+  "9": ["9", "9"],
+  " ": ["  ", "  "],
+  "!": ["!", "."],
+  "?": ["?", "."],
+  ".": [" ", "."],
+  ",": [" ", ","],
+  "-": ["-", " "],
+  ":": [":", ":"]
+};
+var DOTS_FONT = {
+  "A": [".::.", ":..:", "::::", ":  :"],
+  "B": ["::. ", "::.:", "::. ", ":::,"],
+  "C": [".:::", ":   ", ":   ", ".:::"],
+  "D": ["::. ", ":  :", ":  :", "::. "],
+  "E": ["::::", "::: ", "::: ", "::::"],
+  "F": ["::::", "::: ", "::: ", ":   "],
+  "G": [".:::", ":   ", ": ::", ".:::"],
+  "H": [":  :", "::::", ":  :", ":  :"],
+  "I": ["::::", " :  ", " :  ", "::::"],
+  "J": ["::::", " :  ", " :  ", ".:. "],
+  "K": [":  :", ": . ", ":.. ", ":  :"],
+  "L": [":   ", ":   ", ":   ", "::::"],
+  "M": [":   :", ":: ::", ": : :", ":   :"],
+  "N": [":   :", "::  :", ": : :", ":  ::"],
+  "O": [".::.", ":  :", ":  :", ".::."],
+  "P": ["::. ", ":  :", "::. ", ":   "],
+  "Q": [".::.", ":  :", ": .:", ".:.."],
+  "R": ["::. ", ":  :", ":.. ", ":  :"],
+  "S": [".:::", ":   ", " :::", ":::."],
+  "T": ["::::", " :  ", " :  ", " :  "],
+  "U": [":  :", ":  :", ":  :", ".::."],
+  "V": [":  :", ":  :", " :: ", "  : "],
+  "W": [":   :", ":   :", ": : :", " :.: "],
+  "X": [":  :", " :: ", " :: ", ":  :"],
+  "Y": [":  :", " :: ", "  : ", "  : "],
+  "Z": ["::::", "  : ", " :  ", "::::"],
+  "0": [".::.", ":  :", ":  :", ".::."],
+  "1": [" :  ", " :  ", " :  ", " :  "],
+  "2": [".::.", "  ::", ".::.", "::.."],
+  "3": [".::.", " ..:", "  .:", ".::."],
+  "4": [":  :", "::::", "   :", "   :"],
+  "5": ["::::", ":::.", "   :", ":::."],
+  "6": [".::.", ":::.", ":  :", ".::."],
+  "7": ["::::", "   :", "  : ", "  : "],
+  "8": [".::.", ".::.", ".::.", ".::."],
+  "9": [".::.", ":  :", " :::", ".::."],
+  " ": ["    ", "    ", "    ", "    "],
+  "!": [" :: ", " :: ", "    ", " :: "],
+  "?": [".::.", "  ::", "    ", "  : "],
+  ".": ["    ", "    ", "    ", " :: "],
+  ",": ["    ", "    ", " :  ", ":   "],
+  "-": ["    ", "::::", "    ", "    "],
+  ":": ["    ", " :: ", "    ", " :: "]
+};
+var ASCII_FONTS = {
+  block: BLOCK_FONT,
+  banner: BANNER_FONT,
+  small: SMALL_FONT,
+  dots: DOTS_FONT
+};
+function getCharData(font, char) {
+  const upper = char.toUpperCase();
+  if (font[upper]) return font[upper];
+  if (font[char]) return font[char];
+  return font[" "] || ["   ", "   ", "   "];
+}
+function textToAscii(text, options) {
+  const font = options?.font ?? "block";
+  const maxWidth = options?.width ?? 80;
+  const align = options?.align ?? "left";
+  const fontData = ASCII_FONTS[font];
+  if (!text) return "";
+  const chars = text.split("");
+  const charDataList = chars.map((c) => getCharData(fontData, c));
+  const height = charDataList[0]?.length ?? 0;
+  const lines = [];
+  for (let row = 0; row < height; row++) {
+    const rowParts = charDataList.map((cd) => cd[row] ?? " ".repeat((cd[0] ?? "").length));
+    let line = rowParts.join(" ");
+    if (line.length > maxWidth) {
+      line = line.slice(0, maxWidth);
+    }
+    lines.push(line);
+  }
+  if (align === "center" || align === "right") {
+    const maxLen = Math.max(...lines.map((l) => l.length));
+    return lines.map((line) => {
+      const pad = maxLen - line.length;
+      if (align === "center") {
+        const left = Math.floor(pad / 2);
+        const right = pad - left;
+        return " ".repeat(left) + line + " ".repeat(right);
+      }
+      return " ".repeat(pad) + line;
+    }).join("\n");
+  }
+  return lines.join("\n");
+}
+function getAvailableFonts() {
+  return [
+    { value: "block", label: "Block", preview: textToAscii("Hi", { font: "block" }) },
+    { value: "banner", label: "Banner", preview: textToAscii("Hi", { font: "banner" }) },
+    { value: "small", label: "Small", preview: textToAscii("Hi", { font: "small" }) },
+    { value: "dots", label: "Dots", preview: textToAscii("Hi", { font: "dots" }) }
+  ];
+}
+function addBorder(text, style) {
+  const lines = text.split("\n");
+  const maxLen = Math.max(...lines.map((l) => l.length));
+  const chars = {
+    box: { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", h: "\u2500", v: "\u2502" },
+    double: { tl: "\u2554", tr: "\u2557", bl: "\u255A", br: "\u255D", h: "\u2550", v: "\u2551" },
+    rounded: { tl: "\u256D", tr: "\u256E", bl: "\u2570", br: "\u256F", h: "\u2500", v: "\u2502" },
+    stars: { tl: "*", tr: "*", bl: "*", br: "*", h: "*", v: "*" }
+  }[style];
+  const top = chars.tl + chars.h.repeat(maxLen + 2) + chars.tr;
+  const bottom = chars.bl + chars.h.repeat(maxLen + 2) + chars.br;
+  const middle = lines.map((l) => chars.v + " " + l.padEnd(maxLen) + " " + chars.v);
+  return [top, ...middle, bottom].join("\n");
+}
+function centerText(text, width) {
+  const lines = text.split("\n");
+  return lines.map((line) => {
+    if (line.length >= width) return line;
+    const pad = width - line.length;
+    const left = Math.floor(pad / 2);
+    const right = pad - left;
+    return " ".repeat(left) + line + " ".repeat(right);
+  }).join("\n");
+}
+var MORSE_CODE = {
+  "A": ".-",
+  "B": "-...",
+  "C": "-.-.",
+  "D": "-..",
+  "E": ".",
+  "F": "..-.",
+  "G": "--.",
+  "H": "....",
+  "I": "..",
+  "J": ".---",
+  "K": "-.-",
+  "L": ".-..",
+  "M": "--",
+  "N": "-.",
+  "O": "---",
+  "P": ".--.",
+  "Q": "--.-",
+  "R": ".-.",
+  "S": "...",
+  "T": "-",
+  "U": "..-",
+  "V": "...-",
+  "W": ".--",
+  "X": "-..-",
+  "Y": "-.--",
+  "Z": "--..",
+  "0": "-----",
+  "1": ".----",
+  "2": "..---",
+  "3": "...--",
+  "4": "....-",
+  "5": ".....",
+  "6": "-....",
+  "7": "--...",
+  "8": "---..",
+  "9": "----.",
+  ".": ".-.-.-",
+  ",": "--..--",
+  "?": "..--..",
+  "'": ".----.",
+  "!": "-.-.--",
+  "/": "-..-.",
+  "(": "-.--.",
+  ")": "-.--.-",
+  "&": ".-...",
+  ";": "-.-.-.",
+  "=": "-...-",
+  "+": ".-.-.",
+  "-": "-....-",
+  "_": "..--.-",
+  '"': ".-..-.",
+  "$": "...-..-",
+  "@": ".--.-."
+};
+var MORSE_TO_TEXT = Object.fromEntries(
+  Object.entries(MORSE_CODE).map(([k, v]) => [v, k])
+);
+function applyDotDash(morse, dotChar, dashChar) {
+  return morse.replace(/\./g, dotChar).replace(/-/g, dashChar);
+}
+function normalizeDotDash(morse, dotChar, dashChar) {
+  if (dotChar === "." && dashChar === "-") return morse;
+  const escapedDot = dotChar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedDash = dashChar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return morse.replace(new RegExp(escapedDash, "g"), "-").replace(new RegExp(escapedDot, "g"), ".");
+}
+function textToMorse(text, options) {
+  const separator = options?.separator ?? " ";
+  const wordSeparator = options?.wordSeparator ?? " / ";
+  const dotChar = options?.dotChar ?? ".";
+  const dashChar = options?.dashChar ?? "-";
+  const words = text.trim().toUpperCase().split(/\s+/);
+  const morseWords = words.map((word) => {
+    const chars = word.split("");
+    const morseChars = chars.map((c) => MORSE_CODE[c]).filter((m) => m !== void 0);
+    return morseChars.map((m) => applyDotDash(m, dotChar, dashChar)).join(separator);
+  });
+  return morseWords.join(wordSeparator);
+}
+function morseToText(morse, options) {
+  const separator = options?.separator ?? " ";
+  const wordSeparator = options?.wordSeparator ?? " / ";
+  const dotChar = options?.dotChar ?? ".";
+  const dashChar = options?.dashChar ?? "-";
+  const normalized = normalizeDotDash(morse.trim(), dotChar, dashChar);
+  const wordSepNormalized = normalizeDotDash(wordSeparator, dotChar, dashChar);
+  const sepNormalized = normalizeDotDash(separator, dotChar, dashChar);
+  const wordSepEscaped = wordSepNormalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const words = normalized.split(new RegExp(wordSepEscaped));
+  const result = [];
+  for (const word of words) {
+    const sepEscaped = sepNormalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const chars = word.trim().split(new RegExp(sepEscaped)).filter(Boolean);
+    const decoded = [];
+    for (const c of chars) {
+      const letter = MORSE_TO_TEXT[c];
+      if (!letter) return { error: `Unknown morse sequence: ${c}` };
+      decoded.push(letter);
+    }
+    result.push(decoded.join(""));
+  }
+  return result.join(" ");
+}
+function isValidMorse(morse) {
+  const tokens = morse.trim().split(/\s+/);
+  for (const token of tokens) {
+    if (token === "/") continue;
+    if (!/^[.\-]+$/.test(token)) return false;
+    if (!MORSE_TO_TEXT[token]) return false;
+  }
+  return true;
+}
+function getMorseForChar(char) {
+  return MORSE_CODE[char.toUpperCase()] ?? null;
+}
+function getMorseTiming(morse) {
+  const result = [];
+  const tokens = morse.trim().split(" ");
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === "/") {
+      result.push({ type: "wordgap", duration: 700 });
+      continue;
+    }
+    for (let j = 0; j < token.length; j++) {
+      if (token[j] === ".") {
+        result.push({ type: "dot", duration: 100 });
+      } else if (token[j] === "-") {
+        result.push({ type: "dash", duration: 300 });
+      }
+      if (j < token.length - 1) {
+        result.push({ type: "gap", duration: 100 });
+      }
+    }
+    if (i < tokens.length - 1 && tokens[i + 1] !== "/") {
+      result.push({ type: "gap", duration: 100 });
+    }
+  }
+  return result;
+}
+
+exports.CASE_FORMATS = CASE_FORMATS;
+exports.DEFAULT_CONVERT_OPTIONS = DEFAULT_CONVERT_OPTIONS;
+exports.ESCAPE_MODES = ESCAPE_MODES;
+exports.LINE_OPS = LINE_OPS;
+exports.MORSE_CODE = MORSE_CODE;
+exports.addBorder = addBorder;
+exports.analyzeText = analyzeText;
+exports.applyOp = applyOp;
+exports.applyOps = applyOps;
+exports.centerText = centerText;
+exports.convertAll = convertAll;
+exports.convertCase = convertCase;
+exports.countWords = countWords;
+exports.csvToHtml = csvToHtml;
+exports.csvToMarkdown = csvToMarkdown;
+exports.detectDelimiter = detectDelimiter;
+exports.diffLines = diffLines;
+exports.diffLinesSimple = diffLinesSimple;
+exports.diffStats = diffStats;
+exports.escapeAll = escapeAll;
+exports.escapeString = escapeString;
+exports.extractHeadings = extractHeadings;
+exports.formatReadingTime = formatReadingTime;
+exports.generate = generate;
+exports.generateDiff = generateDiff;
+exports.generateHtmlTable = generateHtmlTable;
+exports.generateMarkdownTable = generateMarkdownTable;
+exports.generateParagraphs = generateParagraphs;
+exports.generateSentences = generateSentences;
+exports.generateWords = generateWords;
+exports.getAvailableFonts = getAvailableFonts;
+exports.getMorseForChar = getMorseForChar;
+exports.getMorseTiming = getMorseTiming;
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.isValidMorse = isValidMorse;
+exports.markdownToHtml = markdownToHtml;
+exports.morseToText = morseToText;
+exports.numberToOrdinal = numberToOrdinal;
+exports.numberToRoman = numberToRoman;
+exports.numberToWords = numberToWords;
+exports.ordinalWords = ordinalWords;
+exports.parseDiff = parseDiff;
+exports.parseTableData = parseTableData;
+exports.readabilityScore = readabilityScore;
+exports.renderMarkdown = renderMarkdown;
+exports.romanToNumber = romanToNumber;
+exports.sentenceCount = sentenceCount;
+exports.slugify = slugify;
+exports.slugifyAll = slugifyAll;
+exports.syllableCount = syllableCount;
+exports.textToAscii = textToAscii;
+exports.textToMorse = textToMorse;
+exports.unescapeString = unescapeString;
+exports.wordFrequency = wordFrequency;