@rahularya01/pi-essentials 0.1.0

package/src/web/cache.ts

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { ensureDir, writePrivateFile } from "../config.ts";
+import { getWebCacheDir } from "../paths.ts";
+import { WEB_CACHE_MAX_BYTES, WEB_CACHE_MAX_ENTRIES, WEB_CACHE_TTL_MS } from "../security/limits.ts";
+
+export interface CacheEntry {
+  id: string;
+  url: string;
+  title: string;
+  markdown: string;
+  createdAt: number;
+}
+
+interface IndexEntry {
+  id: string;
+  url: string;
+  title: string;
+  createdAt: number;
+  bytes: number;
+}
+
+interface IndexFile {
+  entries: IndexEntry[];
+}
+
+const ID_PATTERN = /^[0-9a-f]{16}$/;
+
+function indexPath(): string {
+  return path.join(getWebCacheDir(), "index.json");
+}
+
+function entryPath(id: string): string {
+  return path.join(getWebCacheDir(), `${id}.md`);
+}
+
+function isIndexEntry(value: unknown): value is IndexEntry {
+  if (!value || typeof value !== "object") return false;
+  const row = value as Partial<IndexEntry>;
+  return (
+    typeof row.id === "string" &&
+    ID_PATTERN.test(row.id) &&
+    typeof row.url === "string" &&
+    typeof row.createdAt === "number" &&
+    typeof row.bytes === "number"
+  );
+}
+
+function loadIndex(): IndexFile {
+  const file = indexPath();
+  if (!fs.existsSync(file)) return { entries: [] };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as Partial<IndexFile>;
+    if (!Array.isArray(parsed.entries)) return { entries: [] };
+    return {
+      entries: parsed.entries.filter(isIndexEntry).map((row) => ({ ...row, title: String(row.title ?? row.url) })),
+    };
+  } catch {
+    return { entries: [] };
+  }
+}
+
+function saveIndex(index: IndexFile): void {
+  ensureDir(getWebCacheDir());
+  writePrivateFile(indexPath(), `${JSON.stringify(index)}\n`);
+}
+
+export function cacheId(url: string): string {
+  return createHash("sha256").update(url).digest("hex").slice(0, 16);
+}
+
+export function putCache(url: string, title: string, markdown: string): string {
+  const id = cacheId(url);
+  try {
+    ensureDir(getWebCacheDir());
+    writePrivateFile(entryPath(id), markdown);
+    const index = loadIndex();
+    const entries = index.entries.filter((e) => e.id !== id);
+    entries.unshift({ id, url, title, createdAt: Date.now(), bytes: Buffer.byteLength(markdown, "utf8") });
+    prune(entries);
+    saveIndex({ entries });
+  } catch {
+    // A failing cache must never fail the fetch; the caller still gets the page.
+  }
+  return id;
+}
+
+export function getCache(idOrUrl: string): CacheEntry | undefined {
+  const index = loadIndex();
+  const meta = index.entries.find((e) => e.id === idOrUrl || e.url === idOrUrl);
+  if (!meta) return undefined;
+  if (Date.now() - meta.createdAt > WEB_CACHE_TTL_MS) return undefined;
+  try {
+    const markdown = fs.readFileSync(entryPath(meta.id), "utf8");
+    return { id: meta.id, url: meta.url, title: meta.title, markdown, createdAt: meta.createdAt };
+  } catch {
+    return undefined;
+  }
+}
+
+export function sliceMarkdown(markdown: string, offset = 0, limit?: number): { text: string; total: number; start: number } {
+  const total = markdown.length;
+  const start = Math.min(Math.max(0, Math.floor(offset)), total);
+  const end = limit !== undefined && Number.isFinite(limit) ? start + Math.max(0, Math.floor(limit)) : total;
+  return { text: markdown.slice(start, end), total, start };
+}
+
+function prune(entries: IndexEntry[]): void {
+  const now = Date.now();
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (now - entries[i].createdAt > WEB_CACHE_TTL_MS) {
+      unlink(entries[i].id);
+      entries.splice(i, 1);
+    }
+  }
+  while (entries.length > WEB_CACHE_MAX_ENTRIES) {
+    const removed = entries.pop();
+    if (removed) unlink(removed.id);
+  }
+  let total = entries.reduce((sum, e) => sum + e.bytes, 0);
+  while (total > WEB_CACHE_MAX_BYTES && entries.length > 1) {
+    const removed = entries.pop();
+    if (!removed) break;
+    total -= removed.bytes;
+    unlink(removed.id);
+  }
+  removeOrphans(new Set(entries.map((entry) => entry.id)));
+}
+
+/** Drop `.md` files the index no longer references (crash or lost-update leftovers). */
+function removeOrphans(live: Set<string>): void {
+  let files: string[];
+  try {
+    files = fs.readdirSync(getWebCacheDir());
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const id = file.slice(0, -3);
+    if (!ID_PATTERN.test(id) || live.has(id)) continue;
+    unlink(id);
+  }
+}
+
+function unlink(id: string): void {
+  try {
+    fs.rmSync(entryPath(id), { force: true });
+  } catch {
+    // ignore
+  }
+}

package/src/web/extract.ts

@@ -0,0 +1,75 @@
+import { Readability } from "@mozilla/readability";
+import { parseHTML } from "linkedom";
+import { htmlToMarkdown } from "./html-to-markdown.ts";
+
+export interface ExtractedPage {
+  title: string;
+  url: string;
+  markdown: string;
+  byline?: string;
+}
+
+/** Page chrome to drop when Readability cannot identify an article. */
+const CHROME_SELECTOR = "nav, header, footer, aside, form, [role=navigation], [role=banner], [role=contentinfo]";
+
+const TITLE_META = [
+  'meta[property="og:title"]',
+  'meta[name="og:title"]',
+  'meta[name="twitter:title"]',
+  'meta[name="title"]',
+];
+
+function clean(value: string | null | undefined): string {
+  return (value ?? "").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Resolve a page title from the most reliable source available.
+ *
+ * `document.title` is deliberately not trusted: linkedom returns an empty string
+ * for it on real-world pages whose `<head>` it parses loosely, even when a
+ * `<title>` element is present and reachable via `querySelector`.
+ */
+export function extractTitle(document: Document | ReturnType<typeof parseHTML>["document"]): string {
+  const tag = clean(document.querySelector?.("title")?.textContent);
+  if (tag) return tag;
+  for (const selector of TITLE_META) {
+    const meta = clean(document.querySelector?.(selector)?.getAttribute("content"));
+    if (meta) return meta;
+  }
+  return clean(document.querySelector?.("h1")?.textContent);
+}
+
+export function extractReadable(html: string, url: string): ExtractedPage {
+  const { document } = parseHTML(html);
+  let title = extractTitle(document);
+
+  let markdown = "";
+  let byline: string | undefined;
+  try {
+    // Readability mutates the document it is given, so parse a second copy.
+    const article = new Readability(parseHTML(html).document as unknown as Document, { charThreshold: 80 }).parse();
+    if (article?.content) {
+      const parsed = parseHTML(`<div>${article.content}</div>`);
+      markdown = htmlToMarkdown(parsed.document.body);
+      // Readability's title is cleaner when it finds one, but it is often empty.
+      title = clean(article.title) || title;
+      byline = clean(article.byline) || undefined;
+    }
+  } catch {
+    markdown = "";
+  }
+
+  if (!markdown.trim()) {
+    for (const node of Array.from(document.querySelectorAll(CHROME_SELECTOR))) {
+      node.remove?.();
+    }
+    markdown = htmlToMarkdown(document);
+  }
+
+  if (!markdown.trim()) {
+    markdown = clean(document.body?.textContent ?? document.textContent);
+  }
+
+  return { title: title || url, url, markdown, byline };
+}

package/src/web/fetch.ts

@@ -0,0 +1,167 @@
+import type { ResolvedWebConfig } from "../config.ts";
+import { capText, errorMessage, isAbortError, PiEssentialsError } from "../errors.ts";
+import { SsrfError } from "../security/ssrf.ts";
+import { getCache, putCache, sliceMarkdown } from "./cache.ts";
+import { extractReadable } from "./extract.ts";
+import { safeFetch } from "./http.ts";
+
+export interface FetchPageResult {
+  url: string;
+  title: string;
+  markdown: string;
+  truncated: boolean;
+  cacheId: string;
+  totalChars: number;
+  /** Character offset the returned slice starts at. */
+  offset: number;
+}
+
+/** Content types that carry no readable text. */
+const BINARY_TYPE = /^(?:image|audio|video|font)\/|^application\/(?:pdf|zip|gzip|octet-stream|x-|vnd\.(?!.*\+(?:json|xml)))/i;
+
+/** Content types that are already plain text and must not go through Readability. */
+const PLAIN_TYPE = /(?:^text\/(?:plain|markdown|csv|x-markdown)|json|yaml|javascript|typescript|\+xml$|^text\/xml)/i;
+
+export async function fetchPage(
+  rawUrl: string,
+  config: ResolvedWebConfig["fetch"],
+  signal?: AbortSignal,
+  slice?: { offset?: number; limit?: number },
+  allowedHosts?: ReadonlySet<string>,
+): Promise<FetchPageResult> {
+  try {
+    const response = await safeFetch(rawUrl, {
+      timeoutMs: config.timeoutMs,
+      maxBytes: config.maxBytes,
+      signal,
+      allowedHosts,
+    });
+    const contentType = response.contentType.toLowerCase();
+    if (BINARY_TYPE.test(contentType)) {
+      throw new PiEssentialsError(
+        `${response.url} returned binary content (${contentType || "unknown type"}); web_fetch only reads text pages.`,
+        "WEB_FETCH_BINARY",
+      );
+    }
+
+    let markdown: string;
+    let title = response.url;
+    if (PLAIN_TYPE.test(contentType)) {
+      markdown = response.text();
+    } else {
+      const extracted = extractReadable(response.text(), response.url);
+      markdown = extracted.markdown;
+      title = extracted.title;
+      if (extracted.byline) markdown = `${extracted.byline}\n\n${markdown}`;
+    }
+    if (response.truncated) {
+      markdown += `\n\n[Download stopped at ${config.maxBytes} bytes; the page may continue past this point.]`;
+    }
+    if (!markdown.trim()) {
+      markdown = "(The page returned no readable text. It may require JavaScript.)";
+    }
+    return finish(response.url, title, markdown, config, slice);
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw new PiEssentialsError(`Fetching ${rawUrl} was cancelled or timed out.`, "WEB_FETCH_TIMEOUT", true);
+    }
+    if (error instanceof SsrfError) throw error;
+    if (error instanceof PiEssentialsError && error.code === "WEB_FETCH_BINARY") throw error;
+    if (config.jinaFallback) {
+      try {
+        return await fetchViaJina(rawUrl, config, signal, slice, allowedHosts);
+      } catch (fallbackError) {
+        if (signal?.aborted || isAbortError(fallbackError)) {
+          throw new PiEssentialsError(`Fetching ${rawUrl} was cancelled or timed out.`, "WEB_FETCH_TIMEOUT", true);
+        }
+        throw new PiEssentialsError(
+          `Failed to fetch ${rawUrl}: ${errorMessage(error)}. Jina fallback also failed: ${errorMessage(fallbackError)}`,
+          "WEB_FETCH_FAILED",
+          true,
+        );
+      }
+    }
+    if (error instanceof PiEssentialsError) throw error;
+    throw new PiEssentialsError(`Failed to fetch ${rawUrl}: ${errorMessage(error)}`, "WEB_FETCH_FAILED", true);
+  }
+}
+
+async function fetchViaJina(
+  rawUrl: string,
+  config: ResolvedWebConfig["fetch"],
+  signal: AbortSignal | undefined,
+  slice: { offset?: number; limit?: number } | undefined,
+  allowedHosts: ReadonlySet<string> | undefined,
+): Promise<FetchPageResult> {
+  const response = await safeFetch(`https://r.jina.ai/${rawUrl}`, {
+    timeoutMs: config.timeoutMs,
+    maxBytes: config.maxBytes,
+    signal,
+    allowedHosts,
+    headers: { accept: "text/plain" },
+  });
+  const markdown = response.text() || "(Jina returned no readable text.)";
+  return finish(rawUrl, rawUrl, markdown, config, slice);
+}
+
+function finish(
+  url: string,
+  title: string,
+  markdown: string,
+  config: ResolvedWebConfig["fetch"],
+  slice: { offset?: number; limit?: number } | undefined,
+): FetchPageResult {
+  const id = putCache(url, title, markdown);
+  const offset = Math.max(0, Math.floor(slice?.offset ?? 0));
+  // Never ask for more than maxChars, so capText cannot add a second truncation
+  // note on top of the slice note below.
+  const limit = Math.min(config.maxChars, slice?.limit !== undefined ? Math.max(1, Math.floor(slice.limit)) : config.maxChars);
+  const window = sliceMarkdown(markdown, offset, limit);
+  const capped = capText(window.text, config.maxChars);
+  const shown = capped.text.length;
+  const truncated = capped.truncated || window.start + window.text.length < window.total || window.start > 0;
+  return {
+    url,
+    title,
+    markdown: truncated ? `${capped.text}\n\n${sliceNote(window.start, shown, window.total, id)}` : capped.text,
+    truncated,
+    cacheId: id,
+    totalChars: window.total,
+    offset: window.start,
+  };
+}
+
+function sliceNote(start: number, shown: number, total: number, id: string): string {
+  const end = Math.min(total, start + shown);
+  if (end >= total) {
+    return start === 0 ? "" : `[Showing characters ${start}-${end} of ${total}. End of cached page.]`;
+  }
+  return `[Showing characters ${start}-${end} of ${total}. Continue with web_fetch({ cacheId: "${id}", offset: ${end} }).]`;
+}
+
+export function readCached(idOrUrl: string, offset?: number, limit?: number, maxChars = 32_000): FetchPageResult {
+  const entry = getCache(idOrUrl);
+  if (!entry) {
+    throw new PiEssentialsError(
+      `No cached page for "${idOrUrl}". It may have expired; fetch the url again.`,
+      "WEB_CACHE_MISS",
+    );
+  }
+  const window = sliceMarkdown(entry.markdown, offset ?? 0, Math.min(maxChars, limit ?? maxChars));
+  const capped = capText(window.text, maxChars);
+  const shown = capped.text.length;
+  const truncated = capped.truncated || window.start + shown < window.total || window.start > 0;
+  return {
+    url: entry.url,
+    title: entry.title,
+    markdown: truncated ? `${capped.text}\n\n${sliceNote(window.start, shown, window.total, entry.id)}` : capped.text,
+    truncated,
+    cacheId: entry.id,
+    totalChars: window.total,
+    offset: window.start,
+  };
+}
+
+export function formatPage(result: FetchPageResult): string {
+  return `# ${result.title}\nSource: ${result.url}\nCache-Id: ${result.cacheId}\n\n${result.markdown}`;
+}

package/src/web/html-to-markdown.ts

@@ -0,0 +1,284 @@
+/** Elements whose content is never useful as prose. */
+const SKIP_TAGS = new Set([
+  "SCRIPT",
+  "STYLE",
+  "NOSCRIPT",
+  "TEMPLATE",
+  "SVG",
+  "IFRAME",
+  "CANVAS",
+  "OBJECT",
+  "EMBED",
+  "HEAD",
+  "META",
+  "LINK",
+  "AUDIO",
+  "VIDEO",
+]);
+
+/** Elements rendered inside the current line rather than as their own block. */
+const INLINE_TAGS = new Set([
+  "A",
+  "ABBR",
+  "B",
+  "BDI",
+  "BDO",
+  "BIG",
+  "BR",
+  "CITE",
+  "CODE",
+  "DATA",
+  "DEL",
+  "DFN",
+  "EM",
+  "I",
+  "IMG",
+  "INS",
+  "KBD",
+  "LABEL",
+  "MARK",
+  "Q",
+  "S",
+  "SAMP",
+  "SMALL",
+  "SPAN",
+  "STRIKE",
+  "STRONG",
+  "SUB",
+  "SUP",
+  "TIME",
+  "TT",
+  "U",
+  "VAR",
+  "WBR",
+]);
+
+const MAX_DEPTH = 64;
+
+interface Context {
+  out: string[];
+  pending: string[];
+  listDepth: number;
+}
+
+function collapse(value: string): string {
+  return value.replace(/\s+/g, " ");
+}
+
+function textOf(node: { textContent?: string | null }): string {
+  return collapse(node.textContent ?? "").trim();
+}
+
+export function htmlToMarkdown(root: ParentNode | null | undefined): string {
+  if (!root) return "";
+  const ctx: Context = { out: [], pending: [], listDepth: 0 };
+  walk(pickRoot(root), ctx, 0);
+  flush(ctx);
+  return ctx.out
+    .join("\n\n")
+    .replace(/[ \t]+$/gm, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function pickRoot(root: ParentNode): ParentNode {
+  const body = (root as ParentNode & { body?: ParentNode | null }).body;
+  if (body && (body.childNodes?.length ?? 0) > 0) return body;
+  if ((root.childNodes?.length ?? 0) > 0) return root;
+  return body ?? root;
+}
+
+function flush(ctx: Context): void {
+  const text = collapse(ctx.pending.join("")).trim();
+  ctx.pending.length = 0;
+  if (text) ctx.out.push(text);
+}
+
+function pushBlock(ctx: Context, block: string): void {
+  flush(ctx);
+  const trimmed = block.replace(/\s+$/, "");
+  if (trimmed.trim()) ctx.out.push(trimmed);
+}
+
+function walk(node: ParentNode, ctx: Context, depth: number): void {
+  if (depth > MAX_DEPTH) return;
+  for (const child of Array.from(node.childNodes ?? [])) {
+    handle(child as ChildNode, ctx, depth);
+  }
+}
+
+function handle(node: ChildNode, ctx: Context, depth: number): void {
+  if (node.nodeType === 3) {
+    const text = collapse(node.textContent ?? "");
+    if (text.trim()) ctx.pending.push(text);
+    return;
+  }
+  if (node.nodeType !== 1) return;
+
+  const el = node as Element;
+  const tag = el.tagName.toUpperCase();
+  if (SKIP_TAGS.has(tag)) return;
+
+  if (INLINE_TAGS.has(tag)) {
+    ctx.pending.push(inline(el, depth + 1));
+    return;
+  }
+
+  if (/^H[1-6]$/.test(tag)) {
+    const heading = textOf(el);
+    if (heading) pushBlock(ctx, `${"#".repeat(Number(tag[1]))} ${heading}`);
+    return;
+  }
+  if (tag === "HR") {
+    pushBlock(ctx, "---");
+    return;
+  }
+  if (tag === "PRE") {
+    pushBlock(ctx, codeBlock(el));
+    return;
+  }
+  if (tag === "UL" || tag === "OL") {
+    pushBlock(ctx, list(el, tag === "OL", ctx.listDepth, depth + 1));
+    return;
+  }
+  if (tag === "LI") {
+    // A stray <li> outside a list still reads better as a bullet.
+    pushBlock(ctx, `- ${inline(el, depth + 1)}`);
+    return;
+  }
+  if (tag === "TABLE") {
+    pushBlock(ctx, table(el, depth + 1));
+    return;
+  }
+  if (tag === "BLOCKQUOTE") {
+    const inner = htmlToMarkdown(el);
+    if (inner.trim()) {
+      pushBlock(
+        ctx,
+        inner
+          .split("\n")
+          .map((line) => (line ? `> ${line}` : ">"))
+          .join("\n"),
+      );
+    }
+    return;
+  }
+  if (tag === "DT") {
+    pushBlock(ctx, `**${inline(el, depth + 1)}**`);
+    return;
+  }
+  if (tag === "DD") {
+    pushBlock(ctx, `  ${inline(el, depth + 1)}`);
+    return;
+  }
+
+  // Any other block-level container: keep its children in separate blocks.
+  flush(ctx);
+  walk(el, ctx, depth + 1);
+  flush(ctx);
+}
+
+function codeBlock(el: Element): string {
+  const code = el.querySelector?.("code") ?? null;
+  const className = code?.getAttribute("class") ?? el.getAttribute("class") ?? "";
+  const language = /(?:language|lang)-([\w+#-]+)/i.exec(className)?.[1] ?? "";
+  const body = (el.textContent ?? "").replace(/\n+$/, "");
+  if (!body.trim()) return "";
+  return `\`\`\`${language}\n${body}\n\`\`\``;
+}
+
+function list(el: Element, ordered: boolean, listDepth: number, depth: number): string {
+  if (depth > MAX_DEPTH) return "";
+  const indent = "  ".repeat(listDepth);
+  const start = Number.parseInt(el.getAttribute("start") ?? "1", 10);
+  const lines: string[] = [];
+  let index = Number.isFinite(start) ? start : 1;
+
+  for (const child of Array.from(el.children ?? [])) {
+    const item = child as Element;
+    if (item.tagName.toUpperCase() !== "LI") continue;
+    const marker = ordered ? `${index++}.` : "-";
+    const nested: string[] = [];
+    const own: string[] = [];
+
+    for (const part of Array.from(item.childNodes ?? [])) {
+      const partTag = part.nodeType === 1 ? (part as Element).tagName.toUpperCase() : "";
+      if (partTag === "UL" || partTag === "OL") {
+        nested.push(list(part as Element, partTag === "OL", listDepth + 1, depth + 1));
+      } else if (part.nodeType === 3) {
+        own.push(collapse(part.textContent ?? ""));
+      } else if (part.nodeType === 1) {
+        own.push(INLINE_TAGS.has(partTag) ? inline(part as Element, depth + 1) : `${inline(part as Element, depth + 1)} `);
+      }
+    }
+
+    const text = collapse(own.join("")).trim();
+    lines.push(`${indent}${marker} ${text}`.replace(/\s+$/, ""));
+    for (const block of nested) {
+      if (block.trim()) lines.push(block);
+    }
+  }
+  return lines.join("\n");
+}
+
+function table(el: Element, depth: number): string {
+  if (depth > MAX_DEPTH) return "";
+  const rows = Array.from(el.querySelectorAll?.("tr") ?? []) as Element[];
+  if (rows.length === 0) return "";
+
+  const grid = rows.map((row) =>
+    (Array.from(row.children ?? []) as Element[])
+      .filter((cell) => ["TD", "TH"].includes(cell.tagName.toUpperCase()))
+      .map((cell) => inline(cell, depth + 1).replace(/\|/g, "\\|") || " "),
+  );
+  const width = Math.max(...grid.map((row) => row.length));
+  if (width === 0) return "";
+
+  const padded = grid.map((row) => [...row, ...new Array<string>(width - row.length).fill(" ")]);
+  const headerIsLabels = rows[0].querySelector?.("th") !== null;
+  const header = headerIsLabels ? padded[0] : new Array<string>(width).fill(" ");
+  const body = headerIsLabels ? padded.slice(1) : padded;
+
+  const lines = [`| ${header.join(" | ")} |`, `| ${new Array<string>(width).fill("---").join(" | ")} |`];
+  for (const row of body) lines.push(`| ${row.join(" | ")} |`);
+  return lines.join("\n");
+}
+
+function inline(el: Element, depth: number): string {
+  if (depth > MAX_DEPTH) return textOf(el);
+  const tag = el.tagName.toUpperCase();
+
+  if (tag === "BR" || tag === "WBR") return " ";
+  if (tag === "IMG") {
+    const src = el.getAttribute("src") ?? "";
+    const alt = collapse(el.getAttribute("alt") ?? "").trim();
+    return src ? `![${alt}](${src})` : alt;
+  }
+  if (tag === "CODE" || tag === "KBD" || tag === "SAMP") {
+    const code = textOf(el);
+    return code ? `\`${code}\`` : "";
+  }
+
+  const parts: string[] = [];
+  for (const child of Array.from(el.childNodes ?? [])) {
+    if (child.nodeType === 3) {
+      parts.push(collapse(child.textContent ?? ""));
+      continue;
+    }
+    if (child.nodeType !== 1) continue;
+    const nested = child as Element;
+    if (SKIP_TAGS.has(nested.tagName.toUpperCase())) continue;
+    parts.push(inline(nested, depth + 1));
+  }
+  const content = collapse(parts.join("")).trim();
+
+  if (tag === "A") {
+    const href = el.getAttribute("href") ?? "";
+    if (!href || href.startsWith("javascript:")) return content;
+    return content ? `[${content}](${href})` : href;
+  }
+  if (tag === "STRONG" || tag === "B") return content ? `**${content}**` : "";
+  if (tag === "EM" || tag === "I") return content ? `_${content}_` : "";
+  if (tag === "DEL" || tag === "S" || tag === "STRIKE") return content ? `~~${content}~~` : "";
+  return content;
+}