hast-latex 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import * as Latex from "@unified-latex/unified-latex-types";
+import { Root } from "hast";
+import { Plugin } from "unified";
+
+//#region lib/unified-hast-to-latex/index.d.ts
+interface RehypeUnifiedLatexOptions {
+  documentClass?: 'article' | 'report' | 'book';
+}
+declare const rehypeUnifiedLatex: Plugin<[(RehypeUnifiedLatexOptions | null | undefined)?], Root, Latex.Root>;
+//#endregion
+export { type RehypeUnifiedLatexOptions, rehypeUnifiedLatex };

package/dist/index.mjs

@@ -0,0 +1,241 @@
+import { args, m } from "@unified-latex/unified-latex-builder";
+import { visit } from "unist-util-visit";
+
+//#region lib/utils/getClassList.ts
+function getClassList(node) {
+	if (!hasClassList(node)) return [];
+	const className = node.properties?.className;
+	if (Array.isArray(className)) return className.map(String);
+	if (typeof className === "string") return className.split(/\s+/);
+	return [];
+}
+
+//#endregion
+//#region lib/unified-hast-to-latex/collect-body.ts
+function getBody(tree) {
+	const html = tree.children.find((node) => node.type === "element" && node.tagName === "html");
+	if (!html) return void 0;
+	return html.children.find((node) => node.type === "element" && node.tagName === "body");
+}
+function hastNodeToLatex(node) {
+	if (node.type === "text") return textToLatexNodes(node.value);
+	if (node.type === "element") {
+		if (isHeading(node)) return [convertHeading(node)];
+		if (isPageNumber(node)) return [];
+		if (isChapterBlock(node)) return convertChapterBlock(node);
+		if (node.tagName === "p") return convertParagraph(node);
+		if (node.tagName === "span") return convertSpan(node);
+		if (node.tagName === "i") return maybeApplyMacro(node, flattenText(node.children));
+		if (node.tagName === "em") return maybeApplyMacro(node, flattenText(node.children));
+		if (node.tagName === "b") return maybeApplyMacro(node, flattenText(node.children));
+		if (node.tagName === "strong") return maybeApplyMacro(node, flattenText(node.children));
+	}
+	return [];
+}
+function isPageNumber(node) {
+	const classList = getClassList(node);
+	return classList.includes("page-number") || classList.includes("pagenum");
+}
+function isHeading(node) {
+	return node.tagName in HEADING_TAG_TO_MACRO;
+}
+function convertHeading(node) {
+	const macroName = HEADING_TAG_TO_MACRO[node.tagName] ?? "section";
+	const isStarred = getClassList(node).includes("starred");
+	const titleContent = flattenText(node.children);
+	const starredArg = {
+		type: "argument",
+		content: isStarred ? [{
+			type: "string",
+			content: "*"
+		}] : [],
+		openMark: "",
+		closeMark: ""
+	};
+	const emptyArg = {
+		type: "argument",
+		content: [],
+		openMark: "",
+		closeMark: ""
+	};
+	return {
+		type: "macro",
+		content: macroName,
+		_renderInfo: HEADING_RENDER_INFO,
+		args: [
+			starredArg,
+			emptyArg,
+			emptyArg,
+			{
+				type: "argument",
+				content: titleContent,
+				openMark: "{",
+				closeMark: "}"
+			}
+		]
+	};
+}
+function convertParagraph(node) {
+	return node.children.flatMap((child) => hastNodeToLatex(child));
+}
+function convertSpan(node) {
+	return maybeApplyMacro(node, flattenText(node.children));
+}
+function hasFollowingParagraph(nodes, startIndex) {
+	for (let i = startIndex; i < nodes.length; i += 1) {
+		const next = nodes[i];
+		if (next.type === "text" && next.value.trim() === "") continue;
+		if (next.type === "element" && next.tagName === "p") return true;
+		if (next.type === "element") return false;
+	}
+	return false;
+}
+function isParagraph(node) {
+	return node.type === "element" && node.tagName === "p";
+}
+function textToLatexNodes(value) {
+	if (!value.trim()) return [];
+	return value.replace(/’/g, "'").split(/(\s+|['’]|[.,!?;:])/).filter(Boolean).map((part) => {
+		if (/^\s+$/.test(part)) return { type: "whitespace" };
+		if (part === "'" || part === "’") return {
+			type: "string",
+			content: "'"
+		};
+		return {
+			type: "string",
+			content: part
+		};
+	});
+}
+function isChapterBlock(node) {
+	return getClassList(node).includes("chapter") && node.tagName === "div";
+}
+function convertChapterBlock(node) {
+	const chapterTitleNodes = [];
+	visit(node, (node$1) => {
+		if (node$1.type === "element" && isHeading(node$1)) {
+			let text = "";
+			visit(node$1, (child) => {
+				if (child.type === "text") text += child.value;
+			});
+			if (typeof text === "string" && text.trim() !== "") chapterTitleNodes.push(text);
+		}
+	});
+	const chapterTitle = chapterTitleNodes.at(0);
+	const chapterSubtitle = chapterTitleNodes.at(1);
+	if (!chapterTitle) return [];
+	return [{
+		type: "macro",
+		content: "chapter",
+		args: [{
+			closeMark: "}",
+			openMark: "{",
+			type: "argument",
+			content: [{
+				type: "string",
+				content: chapterTitle
+			}]
+		}]
+	}, ...chapterSubtitle ? [{
+		type: "macro",
+		content: "section*",
+		args: [{
+			closeMark: "}",
+			openMark: "{",
+			type: "argument",
+			content: [{
+				type: "string",
+				content: chapterSubtitle
+			}]
+		}]
+	}] : []];
+}
+function maybeApplyMacro(element, children) {
+	const classList = getClassList(element);
+	let macroName = null;
+	if (classList.includes("smcap")) macroName = "textsc";
+	if (element.tagName === "i" || element.tagName === "em") macroName = "textit";
+	if (element.tagName === "b" || element.tagName === "strong") macroName = "textbf";
+	if (!macroName) return children;
+	return m(macroName, children);
+}
+function flattenText(children) {
+	return children.flatMap((child) => {
+		if (child.type === "text") return textToLatexNodes(child.value);
+		if (child.type === "element") return flattenText(child.children);
+		return [];
+	});
+}
+function hasClassList(node) {
+	const className = node.properties?.className;
+	return Array.isArray(className) ? className.length > 0 : typeof className === "string" && className.trim() !== "";
+}
+const HEADING_RENDER_INFO = {
+	breakAround: true,
+	namedArguments: [
+		"starred",
+		null,
+		"tocTitle",
+		"title"
+	]
+};
+const HEADING_TAG_TO_MACRO = {
+	h1: "section",
+	h2: "section",
+	h3: "section",
+	h4: "section",
+	h5: "section",
+	h6: "section"
+};
+
+//#endregion
+//#region lib/unified-hast-to-latex/collect-meta.ts
+function getHead(tree) {
+	const html = tree.children.find((node) => node.type === "element" && node.tagName === "html");
+	if (!html) return void 0;
+	return html.children.find((node) => node.type === "element" && node.tagName === "head");
+}
+function applyMetaToLatex(tree, latexAst) {
+	const head = getHead(tree);
+	if (!head) return latexAst;
+	const metaNodes = [m("usepackage", args(["T1", "fontenc"], { braces: "[]{}" }))];
+	for (const child of head.children) if (child.type === "element" && child.tagName === "meta") {
+		const nameAttr = child.properties?.name;
+		const contentAttr = child.properties?.content;
+		if (typeof nameAttr === "string" && typeof contentAttr === "string") {
+			if (["author", "dc.creator"].includes(nameAttr.toLowerCase())) metaNodes.push(m("author", contentAttr));
+			else if (["title", "dc.title"].includes(nameAttr.toLowerCase())) metaNodes.push(m("title", contentAttr));
+		}
+	}
+	const beginDocIndex = latexAst.content.findIndex((node) => node.type === "macro" && node.content === "begin" && node.args?.[0]?.content?.[0]?.type === "string" && node.args?.[0]?.content?.[0]?.content === "document");
+	if (beginDocIndex !== -1) latexAst.content.splice(beginDocIndex, 0, ...metaNodes);
+	else latexAst.content.unshift(...metaNodes);
+	return latexAst;
+}
+
+//#endregion
+//#region lib/unified-hast-to-latex/index.ts
+const rehypeUnifiedLatex = (options = { documentClass: "book" }) => {
+	return (tree) => {
+		getHead(tree);
+		const body = getBody(tree);
+		const content = [];
+		const meaningfulChildren = body?.children ?? [];
+		for (let i = 0; i < meaningfulChildren.length; i += 1) {
+			const child = meaningfulChildren[i];
+			const latexNodes = hastNodeToLatex(child);
+			content.push(...latexNodes);
+			if (isParagraph(child) && hasFollowingParagraph(meaningfulChildren, i + 1)) content.push({ type: "parbreak" });
+		}
+		content.unshift(m("begin", "document"));
+		content.push(m("end", "document"));
+		content.unshift(m("documentclass", options?.documentClass ?? "book"));
+		return applyMetaToLatex(tree, {
+			type: "root",
+			content
+		});
+	};
+};
+
+//#endregion
+export { rehypeUnifiedLatex };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "hast-latex",
+  "description": "Converts HAST to Unified LaTeX AST",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "author": {
+    "name": "Evan Hennessy",
+    "url": "https://www.hennessyevan.com"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "unist",
+    "ast",
+    "latex",
+    "rehype",
+    "unified",
+    "hast",
+    "transformer"
+  ],
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@unified-latex/unified-latex": "^1.8.3",
+    "@unified-latex/unified-latex-builder": "^1.8.3",
+    "@unified-latex/unified-latex-lint": "^1.8.3",
+    "@unified-latex/unified-latex-to-hast": "^1.8.3",
+    "@unified-latex/unified-latex-types": "^1.8.0",
+    "@unified-latex/unified-latex-util-parse": "^1.8.3",
+    "@unified-latex/unified-latex-util-print-raw": "^1.8.0",
+    "@unified-latex/unified-latex-util-render-info": "^1.8.3",
+    "@unified-latex/unified-latex-util-to-string": "^1.8.3",
+    "hast-util-class-list": "^2.0.1",
+    "hast-util-from-html": "^2.0.3",
+    "hast-util-select": "^6.0.4",
+    "hast-util-to-string": "^3.0.1",
+    "prettier-plugin-latex": "^2.0.1",
+    "rehype-parse": "^9.0.1",
+    "tiny-invariant": "^1.3.3",
+    "unified": "^11.0.5",
+    "unist-util-inspect": "^8.1.0",
+    "unist-util-remove": "^4.0.0",
+    "unist-util-select": "^5.1.0",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "tsdown": "0.19.0-beta.3",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "example": "node ./example.ts",
+    "build": "tsdown ./index.ts",
+    "release": "pnpm version patch && pnpm build && git add . && git commit -m 'chore: release' && git push && git push --tags && pnpm publish"
+  }
+}

package/readme.md

@@ -0,0 +1,99 @@
+# hast-latex
+
+A small unifiedJS plugin that turns an HTML/HAST tree into a LaTeX AST (see [unified-latex](https://github.com/siefkenj/unified-latex)) so you can render, lint, or emit `.tex` from HTML sources. Designed for book-like documents (ebooks, etc.) where you want headings, chapters, metadata, and inline formatting to map cleanly into LaTeX.
+
+## Installation
+
+```bash
+npm install hast-latex rehype-parse unified @unified-latex/unified-latex-util-to-string
+```
+
+## Quick start
+
+The plugin consumes a HAST tree (e.g., from `rehype-parse`) and returns a unified-latex AST you can stringify with `@unified-latex/unified-latex-util-to-string`.
+
+```ts
+import { unified } from 'unified'
+import rehypeParse from 'rehype-parse'
+import { hastLatex } from 'hast-latex'
+import { unifiedLatexStringCompiler } from '@unified-latex/unified-latex-util-to-string'
+
+const html = `<html><head><meta name="title" content="Example" /></head><body><h1>Hello</h1><p>World.</p></body></html>`
+
+// Build HAST from HTML
+const rehypeProcessor = unified()
+  .use(rehypeParse)
+  .use(hastLatex, { documentClass: 'book' })
+
+const hast = rehypeProcessor.parse(html)
+const latexAst = rehypeProcessor.runSync(hast)
+
+// Turn LaTeX AST into a .tex string
+const latex = unified().use(unifiedLatexStringCompiler).stringify(latexAst)
+
+console.log(latex)
+```
+
+## API
+
+### `hastLatex(options?)`
+
+Unified plugin that converts HAST → unified-latex AST.
+
+Options:
+
+- `documentClass`: `'article' | 'report' | 'book'` (default: `'book'`). Used for the emitted `\documentclass{...}` macro.
+- `makeTitle`: `boolean` (default: `false`). When `true`, inserts `\maketitle` and uses metadata from the HTML `<head>` (e.g., `<meta name="title">`, `<meta name="author">`, `dc.title`, `dc.creator`) to populate `\title{}` and `\author{}`.
+- `macroReplacements`: `Record<string, string>` mapping CSS selectors to LaTeX macro names for inline styling (e.g., `{ 'b,strong': 'textbf', 'i,em': 'textit' }`). This lets you customize how inline HTML is converted to LaTeX commands.
+
+Default `macroReplacements`:
+
+```ts
+{
+  'b,strong': 'textbf',
+  'i,em': 'textit',
+  u: 'underline',
+  's,strike,del': 'sout',
+}
+```
+
+#### Advanced usage
+
+```ts
+import { unified } from 'unified'
+import rehypeParse from 'rehype-parse'
+import { hastLatex } from 'hast-latex'
+import { unifiedLatexStringCompiler } from '@unified-latex/unified-latex-util-to-string'
+
+const html = `<!doctype html><html><head>
+  <meta name="title" content="My Book" />
+  <meta name="author" content="Jane Doe" />
+</head><body>
+  <h1 class="starred">Intro</h1>
+  <p><span class="smcap">Small Caps</span> and <u>underline</u>.</p>
+</body></html>`
+
+const processor = unified()
+  .use(rehypeParse)
+  .use(hastLatex, {
+    documentClass: 'book',
+    makeTitle: true,
+    macroReplacements: {
+      'span.smcap': 'textsc',
+      u: 'underline',
+    },
+  })
+
+const hast = processor.parse(html)
+const latexAst = processor.runSync(hast as any)
+const latex = unified().use(unifiedLatexStringCompiler).stringify(latexAst)
+
+console.log(latex)
+```
+
+## Notes & limitations
+
+- Currently focused on book-like prose from ebook sources. Lists, images, tables, math, footnotes, etc., are not yet mapped.
+- HTML must include a `<html><head>...</head><body>...</body></html>` structure for metadata extraction.
+- Output is a LaTeX AST; you choose when/how to stringify or compile it.
+- API and output shape will change; pinned at `0.x` while iterating.