@nast/nast2typst 0.2.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,68 @@
+# NAST to Typst (nast2typst)
+This package transforms a unified-like Notion Abstract Sintax Tree (NAST) in JSON format into a string of Typst code (Typst is an alternative to LaTeX).
+
+## Approach
+
+### Preamble
+
+```typ
+// #import "@preview/notionly:0.1.0":  * // When published
+#show: notionly
+```
+
+
+### Notion page information 
+The Notion page information gets simply converted into:
+```typ
+#set document(title: [Here it goes the title of the Notion page])
+
+#align(center)[
+  #scale(160%)[✴️] \ // Emoji or icon of the Notion page
+  #title() \
+]
+```
+
+### Math
+For math we internally use the package `tex2typst` for converting the expressions into Typst math language Sometimes tex2typst fails and then we provide the LaTeX code commented out. Due to the content sometimes being in KaTeX (instead of LaTeX) some things do not work out directly and need to be fixed on our side.
+
+### Callout, toggles, bookmarks, checklists...
+
+
+The Notionly Typst package (made by the same author of this npm package) internally changes some styles (for example of quotes or code blocks) and also exposes some custom functions (like `#callout`) or defines some custom markup (like [X] for checklists) and some custom variables (like the notion palette colors).
+
+## Mapping (Notion → Typst)
+
+### Rich Text (Inline)
+
+| Format | Typst |
+|--------|-------|
+| Bold | `*text*` |
+| Italic | `_text_` |
+| Underline | `#underline[text]` |
+| Strikethrough | `#strike[text]` |
+| Inline code | `` `code` `` |
+| Inline math | `$expression$`|
+| Text color | `#text(fill: text_color)` |
+| Background color | `#highlight(fill: bg_color)` |
+
+### Blocks
+
+| Block Type | Typst |
+|------------|-------|
+| Headings | `=`, `==`, `===` |
+| Divider | `#line(length: 100%, stroke: 0.1pt)` |
+| Quote | `#quote[...]` |
+| Code block | \`\`\`py `print("Works like in markdown...")`  \`\`\` |
+| Callouts | `#callout(icon: "📌", bg: notion.blue_bg)[...]` |
+| Lists (unordered and ordered) | `-` and `+`|
+| Checklists |  `[ ]` and `[X]`
+| Tables | `#table( columns: (1fr, 1fr), align: (left, left),  table.header([*Col1*], [*Col2*]), [cell], [cell])` |
+| Images | `#figure(image("images/image-1.png"), caption: [...])` |
+| Media | Links to original Notion page
+| Bookmarks and Embeds | `#link("url")[...]` |
+| Toggles | `#toggle[title][body]` or `#toggle(heading: 2)[title][body]` |
+| Columns | `#columns(n, gutter: 2em)[... #colbreak() ...]` |
+| Math | `$ [...] $` but converted to Typst math using `text2typst`|
+
+# License
+[MIT](../LICENSE)

package/dist/index-CgBLzCnj.d.ts

@@ -0,0 +1,252 @@
+//#region src/types.d.ts
+interface NASTRoot {
+  type: "root";
+  children: NASTNode[];
+  data: {
+    pageId: string;
+    title: string;
+    icon?: {
+      type: "emoji" | "file" | "external";
+      value: string;
+    };
+    processedAt: string;
+  };
+}
+type NASTNode = NASTParagraph | NASTHeading | NASTText | NASTStrong | NASTEmphasis | NASTUnderline | NASTDelete | NASTInlineCode | NASTLink | NASTMention | NASTMath | NASTInlineMath | NASTCode | NASTBlockquote | NASTCallout | NASTToggle | NASTList | NASTListItem | NASTColumnList | NASTColumn | NASTImage | NASTThematicBreak | NASTTable | NASTTableRow | NASTTableCell | NASTChildPage | NASTVideo | NASTFile | NASTPDF | NASTBookmark | NASTEmbed;
+interface NASTParagraph {
+  type: "paragraph";
+  children: NASTNode[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTHeading {
+  type: "heading";
+  depth: 1 | 2 | 3;
+  children: NASTNode[];
+  isToggleable?: boolean;
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTText {
+  type: "text";
+  value: string;
+  data?: {
+    color?: string;
+    backgroundColor?: string;
+  };
+}
+interface NASTStrong {
+  type: "strong";
+  children: NASTNode[];
+}
+interface NASTEmphasis {
+  type: "emphasis";
+  children: NASTNode[];
+}
+interface NASTUnderline {
+  type: "underline";
+  children: NASTNode[];
+}
+interface NASTDelete {
+  type: "delete";
+  children: NASTNode[];
+}
+interface NASTInlineCode {
+  type: "inlineCode";
+  value: string;
+}
+interface NASTLink {
+  type: "link";
+  url: string;
+  children: NASTNode[];
+  data?: {
+    title?: string;
+    iconUrl?: string;
+    description?: string;
+    provider?: string;
+    thumbnailUrl?: string;
+  };
+}
+interface NASTMention {
+  type: "mention";
+  mentionType: "user" | "date" | "page" | "database";
+  value: string;
+  data: unknown;
+}
+interface NASTMath {
+  type: "math";
+  value: string;
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTInlineMath {
+  type: "inlineMath";
+  value: string;
+}
+interface NASTCode {
+  type: "code";
+  lang: string;
+  value: string;
+  data?: {
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTBlockquote {
+  type: "blockquote";
+  children: NASTNode[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTCallout {
+  type: "callout";
+  data: {
+    icon: {
+      type: "emoji";
+      value: string;
+    } | null;
+    color: string;
+    blockId?: string;
+  };
+  children: NASTNode[];
+}
+interface NASTToggle {
+  type: "toggle";
+  children: NASTNode[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTList {
+  type: "list";
+  ordered: boolean;
+  children: NASTListItem[];
+}
+interface NASTListItem {
+  type: "listItem";
+  children: NASTNode[];
+  checked?: boolean | undefined;
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTColumnList {
+  type: "columnList";
+  children: NASTColumn[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTColumn {
+  type: "column";
+  widthRatio: number;
+  children: NASTNode[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTImage {
+  type: "image";
+  url: string;
+  title: string | null | undefined;
+  alt: string | null | undefined;
+  data: {
+    fileType: "file" | "external";
+    expiryTime?: string;
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTThematicBreak {
+  type: "thematicBreak";
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTTable {
+  type: "table";
+  hasColumnHeader: boolean;
+  hasRowHeader: boolean;
+  children: NASTTableRow[];
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTTableRow {
+  type: "tableRow";
+  children: NASTTableCell[];
+}
+interface NASTTableCell {
+  type: "tableCell";
+  children: NASTNode[];
+}
+interface NASTChildPage {
+  type: "childPage";
+  title: string;
+  pageId: string;
+  data?: {
+    blockId?: string;
+  };
+}
+interface NASTVideo {
+  type: "video";
+  url: string;
+  data: {
+    fileType: "file" | "external";
+    expiryTime?: string;
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTFile {
+  type: "file";
+  url: string;
+  name: string;
+  data: {
+    fileType: "file" | "external";
+    expiryTime?: string;
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTPDF {
+  type: "pdf";
+  url: string;
+  data: {
+    fileType: "file" | "external";
+    expiryTime?: string;
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTBookmark {
+  type: "bookmark";
+  url: string;
+  data?: {
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+interface NASTEmbed {
+  type: "embed";
+  url: string;
+  data?: {
+    caption?: NASTNode[];
+    blockId?: string;
+  };
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Converts a NAST (Unified-like Notion Abstract Syntax Tree) to Typst markup.
+ *
+ * @param root - The NAST root node
+ * @returns Typst markup string
+ */
+declare function nast2typst(root: NASTRoot): string;
+//#endregion
+export { NASTBlockquote, NASTBookmark, NASTCallout, NASTChildPage, NASTCode, NASTColumn, NASTColumnList, NASTDelete, NASTEmbed, NASTEmphasis, NASTFile, NASTHeading, NASTImage, NASTInlineCode, NASTInlineMath, NASTLink, NASTList, NASTListItem, NASTMath, NASTMention, NASTNode, NASTPDF, NASTParagraph, NASTRoot, NASTStrong, NASTTable, NASTTableCell, NASTTableRow, NASTText, NASTThematicBreak, NASTToggle, NASTUnderline, NASTVideo, nast2typst };

package/dist/index.js

@@ -0,0 +1,480 @@
+import { tex2typst } from "tex2typst";
+
+//#region src/lib/handlers/utils.ts
+/**
+* Utility functions for NAST to Typst conversion
+*/
+/**
+* Escapes special characters in Typst text
+*/
+function escapeTypstText(text) {
+	return text.replace(/\\/g, "\\\\").replace(/#/g, "\\#").replace(/\$/g, "\\$").replace(/@/g, "\\@");
+}
+/**
+* Converts Notion color names to Typst color references
+*/
+function notionColorToTypst(notionColor) {
+	return {
+		"gray": "notion.gray_text",
+		"brown": "notion.brown_text",
+		"orange": "notion.orange_text",
+		"yellow": "notion.yellow_text",
+		"green": "notion.green_text",
+		"blue": "notion.blue_text",
+		"purple": "notion.purple_text",
+		"pink": "notion.pink_text",
+		"red": "notion.red_text",
+		"gray_background": "notion.gray_bg",
+		"brown_background": "notion.brown_bg",
+		"orange_background": "notion.orange_bg",
+		"yellow_background": "notion.yellow_bg",
+		"green_background": "notion.green_bg",
+		"blue_background": "notion.blue_bg",
+		"purple_background": "notion.purple_bg",
+		"pink_background": "notion.pink_bg",
+		"red_background": "notion.red_bg"
+	}[notionColor] || notionColor;
+}
+/**
+* Processing context that tracks state during conversion
+*/
+var ProcessingContext = class {
+	imageCounter = 0;
+	pageId;
+	constructor(pageId) {
+		this.pageId = pageId;
+	}
+	/**
+	* Get the next image path and increment counter
+	*/
+	getNextImagePath(url) {
+		this.imageCounter++;
+		const extension = getFileExtension(url);
+		return `images/image-${this.imageCounter}${extension}`;
+	}
+	/**
+	* Get the Notion page URL for this page
+	*/
+	getNotionPageUrl() {
+		return `https://notion.so/${this.pageId}`;
+	}
+};
+/**
+* Strips query parameters from a URL
+*/
+function stripUrlParameters(url) {
+	const urlObj = new URL(url);
+	return urlObj.origin + urlObj.pathname;
+}
+/**
+* Extracts the clean AWS URL without parameters
+*/
+function extractCleanAwsUrl(url) {
+	try {
+		return stripUrlParameters(url);
+	} catch {
+		return url;
+	}
+}
+/**
+* Determines if a URL is an AWS signed URL
+*/
+function isAwsSignedUrl(url) {
+	return url.includes("prod-files-secure.s3") || url.includes("amazonaws.com");
+}
+/**
+* Extracts file extension from a URL
+*/
+function getFileExtension(url) {
+	try {
+		const match = (url.split("?")[0].split("/").pop() || "").match(/\.(\w+)$/);
+		return match ? match[0] : "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Fixes minor KaTeX-specific issues in converted Typst math
+*/
+function fixKatexToTypstConversion(typstMath) {
+	let result = typstMath;
+	for (const cmd of [
+		"Huge",
+		"huge",
+		"LARGE",
+		"Large",
+		"large",
+		"normalsize",
+		"small",
+		"footnotesize",
+		"scriptsize",
+		"tiny"
+	]) result = result.replace(new RegExp(cmd, "g"), "");
+	for (const cmd of [
+		"big",
+		"Big",
+		"bigg",
+		"Bigg"
+	]) result = result.replace(new RegExp(cmd, "g"), "");
+	for (const cmd of [
+		"vphantom",
+		"hphantom",
+		"displaystyle",
+		"textstyle",
+		"scriptstyle"
+	]) result = result.replace(new RegExp(cmd, "g"), "");
+	result = result.replace(/xrightarrow /g, "stretch(->)^");
+	return result;
+}
+
+//#endregion
+//#region src/lib/handlers/text.ts
+function handleText(node) {
+	let text = escapeTypstText(node.value);
+	if (node.data?.color) text = `#text(fill: ${notionColorToTypst(node.data.color)})[${text}]`;
+	if (node.data?.backgroundColor) text = `#highlight(fill: ${notionColorToTypst(node.data.backgroundColor)})[${text}]`;
+	return text;
+}
+function handleStrong(node, context) {
+	return `*${node.children.map((child) => processNode(child, context)).join("")}*`;
+}
+function handleEmphasis(node, context) {
+	return `_${node.children.map((child) => processNode(child, context)).join("")}_`;
+}
+function handleUnderline(node, context) {
+	return `#underline[${node.children.map((child) => processNode(child, context)).join("")}]`;
+}
+function handleDelete(node, context) {
+	return `#strike[${node.children.map((child) => processNode(child, context)).join("")}]`;
+}
+function handleInlineCode(node) {
+	return `\`${node.value}\``;
+}
+
+//#endregion
+//#region src/lib/handlers/math.ts
+function handleMath(node) {
+	try {
+		let typstMath = tex2typst(node.value);
+		typstMath = fixKatexToTypstConversion(typstMath);
+		return `$\n${typstMath}\n$\n`;
+	} catch (error) {
+		return `/*\nFailed to convert the following LaTeX to Typst:\n$\n${node.value}\n$\n*/\n`;
+	}
+}
+function handleInlineMath(node) {
+	try {
+		let typstMath = tex2typst(node.value);
+		typstMath = fixKatexToTypstConversion(typstMath);
+		return `$${typstMath}$`;
+	} catch (error) {
+		return `/*\nFailed to convert the following LaTeX to Typst:\n$${node.value}$\n*/\n`;
+	}
+}
+
+//#endregion
+//#region src/lib/handlers/blocks.ts
+function handleParagraph(node, context) {
+	return node.children.map((child) => processNode(child, context)).join("") + "\\\n";
+}
+function handleBlockquote(node, context) {
+	return `#quote[\n${node.children.map((child) => processNode(child, context)).join("")}]\n`;
+}
+function handleThematicBreak(node) {
+	return `#line(length: 100%, stroke: 0.1pt)\n`;
+}
+function handleCallout(node, context) {
+	const icon = node.data.icon?.value || null;
+	const bgColor = notionColorToTypst(node.data.color);
+	let params = [];
+	if (icon) params.push(`icon: "${icon}"`);
+	params.push(`bg: ${bgColor}`);
+	const content = node.children.map((child) => processNode(child, context)).join("");
+	return `#callout(${params.join(", ")})[\n${content}]\n`;
+}
+function handleCode(node) {
+	return `\`\`\`${node.lang || ""}\n${node.value}\n\`\`\`\n`;
+}
+
+//#endregion
+//#region src/lib/handlers/lists.ts
+let currentListDepth = 0;
+function handleList(node, context) {
+	const marker = node.ordered ? "+" : "-";
+	const indent = "  ".repeat(currentListDepth);
+	currentListDepth++;
+	const items = node.children.map((child) => handleListItem(child, marker, indent, context));
+	currentListDepth--;
+	return items.join("") + (currentListDepth === 0 ? "\n" : "");
+}
+function handleListItem(node, marker, indent, context) {
+	let result = "";
+	let firstBlock = true;
+	const checkboxPrefix = node.checked !== void 0 ? node.checked ? "[X] " : "[ ] " : "";
+	for (const child of node.children) if (child.type === "paragraph") {
+		const content = child.children.map((c) => processNode(c, context)).join("");
+		if (firstBlock) {
+			result += `${indent}${marker} ${checkboxPrefix}${content}\n`;
+			firstBlock = false;
+		} else result += `${indent}  ${content}\n`;
+	} else if (child.type === "list") result += processNode(child, context);
+	else {
+		const processed = processNode(child, context);
+		if (firstBlock) {
+			result += `${indent}${marker} ${checkboxPrefix}${processed}`;
+			firstBlock = false;
+		} else result += `${indent}  ${processed}`;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/lib/handlers/headings.ts
+function handleHeading(node, context) {
+	if (!(node.isToggleable || false)) return `${"=".repeat(node.depth)} ${node.children.map((child) => processNode(child, context)).join("")}\n`;
+	else {
+		const toggleTitle = node.children[0] ? processNode(node.children[0], context) : "Toggle";
+		const toggleChildren = node.children.slice(1).map((child) => processNode(child, context)).join("");
+		return `// Toggle block\n#toggle(heading: ${node.depth})[${toggleTitle}][\n${toggleChildren}\n]`;
+	}
+}
+
+//#endregion
+//#region src/lib/handlers/toggle.ts
+function handleToggle(node, context) {
+	if (node.children.length === 0) return "";
+	const firstChild = node.children[0];
+	let toggleTitle = "";
+	let headingParam = "";
+	let bodyStartIndex = 1;
+	let isHeadingToggle = false;
+	if (firstChild.type === "heading") {
+		headingParam = `heading: ${firstChild.depth}`;
+		toggleTitle = firstChild.children.map((child) => processNode(child, context)).join("");
+		isHeadingToggle = true;
+	} else {
+		toggleTitle = processNode(firstChild, context);
+		bodyStartIndex = 1;
+	}
+	const toggleBody = node.children.slice(bodyStartIndex).map((child) => processNode(child, context)).join("");
+	const toggleParams = headingParam ? `${headingParam}` : "";
+	return `// Toggle block\n${toggleParams ? `#toggle(${toggleParams})` : "#toggle"}[${toggleTitle}${isHeadingToggle ? "\n" : ""}][${toggleBody}]`;
+}
+
+//#endregion
+//#region src/lib/handlers/table.ts
+function handleTable(node, context) {
+	const rows = node.children;
+	if (rows.length === 0) return "";
+	const columnCount = rows[0].children.length;
+	const columns = Array(columnCount).fill("1fr").join(", ");
+	let result = "#table(\n";
+	result += `  columns: (${columns}),\n`;
+	result += `  align: (${Array(columnCount).fill("left").join(", ")}),\n`;
+	if (node.hasColumnHeader && rows.length > 0) {
+		const headerCells = rows[0].children.map((cell) => {
+			return `[*${cell.children.map((child) => processNode(child, context)).join("")}*]`;
+		});
+		result += `  table.header(${headerCells.join(", ")}),\n`;
+		for (let i = 1; i < rows.length; i++) {
+			const rowCells = rows[i].children.map((cell, colIndex) => {
+				const content = cell.children.map((child) => processNode(child, context)).join("");
+				if (colIndex === 0 && node.hasRowHeader) return `[*${content}*]`;
+				return `[${content}]`;
+			});
+			result += `  ${rowCells.join(", ")}${i < rows.length - 1 ? "," : ""}\n`;
+		}
+	} else rows.forEach((row, rowIndex) => {
+		const rowCells = row.children.map((cell, colIndex) => {
+			const content = cell.children.map((child) => processNode(child, context)).join("");
+			if (colIndex === 0 && node.hasRowHeader) return `[*${content}*]`;
+			return `[${content}]`;
+		});
+		result += `  ${rowCells.join(", ")}${rowIndex < rows.length - 1 ? "," : ""}\n`;
+	});
+	result += ")\n";
+	return result;
+}
+
+//#endregion
+//#region src/lib/handlers/media.ts
+function handleImage(node, context) {
+	let imagePath;
+	let comment = "";
+	if (node.data.fileType === "file" && isAwsSignedUrl(node.url)) {
+		imagePath = context.getNextImagePath(node.url);
+		comment = `// Original file: ${extractCleanAwsUrl(node.url)}\n`;
+	} else if (node.data.fileType === "external") {
+		imagePath = context.getNextImagePath(node.url);
+		comment = `// Source URL: ${node.url}\n`;
+	} else imagePath = node.url;
+	let result = comment;
+	if (node.data.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `#figure(\n  image("${imagePath}"),\n  caption: [${caption}]\n)`;
+	} else result += `#figure(\n  image("${imagePath}")\n)`;
+	return result + "\n";
+}
+function handleVideo(node, context) {
+	let videoUrl;
+	let comment = "";
+	if (node.data.fileType === "file" && isAwsSignedUrl(node.url)) {
+		videoUrl = context.getNotionPageUrl();
+		comment = `// Original file: ${extractCleanAwsUrl(node.url)}\n`;
+	} else {
+		videoUrl = context.getNotionPageUrl();
+		comment = `// Source URL: ${node.url}\n`;
+	}
+	let result = comment;
+	result += `#link("${videoUrl}")[🎥 Video]\n`;
+	if (node.data.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `_${caption}_\n`;
+	}
+	return result;
+}
+function handleFile(node, context) {
+	let fileUrl;
+	let comment = "";
+	if (node.data.fileType === "file" && isAwsSignedUrl(node.url)) {
+		fileUrl = context.getNotionPageUrl();
+		comment = `// Original file: ${extractCleanAwsUrl(node.url)}\n`;
+	} else {
+		fileUrl = context.getNotionPageUrl();
+		comment = `// Source URL: ${node.url}\n`;
+	}
+	const fileName = node.name || "File";
+	let result = comment;
+	result += `#link("${fileUrl}")[📄 ${fileName}]\n`;
+	if (node.data.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `_${caption}_\n`;
+	}
+	return result;
+}
+function handlePDF(node, context) {
+	let pdfUrl;
+	let comment = "";
+	if (node.data.fileType === "file" && isAwsSignedUrl(node.url)) {
+		pdfUrl = context.getNotionPageUrl();
+		comment = `// Original file: ${extractCleanAwsUrl(node.url)}\n`;
+	} else {
+		pdfUrl = context.getNotionPageUrl();
+		comment = `// Source URL: ${node.url}\n`;
+	}
+	let result = comment;
+	result += `#link("${pdfUrl}")[📕 PDF Document]\n`;
+	if (node.data.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `_${caption}_\n`;
+	}
+	return result;
+}
+function handleBookmark(node, context) {
+	let result = `#link("${node.url}")[${node.url}]\n`;
+	if (node.data?.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `_${caption}_\n`;
+	}
+	return result;
+}
+function handleEmbed(node, context) {
+	let result = `// Embedded content: ${node.url}\n`;
+	result += `#link("${node.url}")[🔗 Embedded Content]\n`;
+	if (node.data?.caption && node.data.caption.length > 0) {
+		const caption = node.data.caption.map((child) => processNode(child, context)).join("");
+		result += `_${caption}_\n`;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/lib/handlers/misc.ts
+function handleLink(node, context) {
+	const content = node.children.map((child) => processNode(child, context)).join("");
+	return `#link("${node.url}")[${content}]`;
+}
+function handleMention(node) {
+	switch (node.mentionType) {
+		case "user": return `\\${node.value}`;
+		case "date": return node.value;
+		case "page": return `_${node.value}_`;
+		case "database": return `_${node.value}_`;
+		default: return node.value;
+	}
+}
+function handleChildPage(node) {
+	return `${node.title}\n#link("https://notion.so/${node.pageId}")[📄 ${node.title}] // Child page\n`;
+}
+function handleColumnList(node, context) {
+	return `#columns(${node.children.length}, gutter: 2em)[ \n${node.children.map((column) => handleColumn(column, context)).join("#colbreak()\n")}]\n`;
+}
+function handleColumn(node, context) {
+	return node.children.map((child) => processNode(child, context)).join("");
+}
+
+//#endregion
+//#region src/lib/processor.ts
+function processNode(node, context) {
+	switch (node.type) {
+		case "text": return handleText(node);
+		case "strong": return handleStrong(node, context);
+		case "emphasis": return handleEmphasis(node, context);
+		case "underline": return handleUnderline(node, context);
+		case "delete": return handleDelete(node, context);
+		case "inlineCode": return handleInlineCode(node);
+		case "math": return handleMath(node);
+		case "inlineMath": return handleInlineMath(node);
+		case "paragraph": return handleParagraph(node, context);
+		case "heading": return handleHeading(node, context);
+		case "blockquote": return handleBlockquote(node, context);
+		case "thematicBreak": return handleThematicBreak(node);
+		case "callout": return handleCallout(node, context);
+		case "code": return handleCode(node);
+		case "toggle": return handleToggle(node, context);
+		case "list": return handleList(node, context);
+		case "columnList": return handleColumnList(node, context);
+		case "table": return handleTable(node, context);
+		case "image": return handleImage(node, context);
+		case "video": return handleVideo(node, context);
+		case "file": return handleFile(node, context);
+		case "pdf": return handlePDF(node, context);
+		case "bookmark": return handleBookmark(node, context);
+		case "embed": return handleEmbed(node, context);
+		case "link": return handleLink(node, context);
+		case "mention": return handleMention(node);
+		case "childPage": return handleChildPage(node);
+		default:
+			console.warn(`Unhandled node type: ${node.type}`);
+			return "";
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const TEMPORAL_PREAMBLE = `
+#import "src/lib.typ": *
+#show: notionly
+`;
+/**
+* Converts a NAST (Unified-like Notion Abstract Syntax Tree) to Typst markup.
+* 
+* @param root - The NAST root node
+* @returns Typst markup string
+*/
+function nast2typst(root) {
+	let result = TEMPORAL_PREAMBLE;
+	if (root.data.title) {
+		result += `#set document(title: [${root.data.title}])\n\n`;
+		result += `#align(center)[\n`;
+		if (root.data.icon && root.data.icon.type === "emoji") result += `  #scale(160%)[${root.data.icon.value}] \\\n`;
+		result += `  #title() \\\n`;
+		result += `]\n\n`;
+	}
+	const context = new ProcessingContext(root.data.pageId);
+	for (const child of root.children) result += processNode(child, context);
+	return result;
+}
+
+//#endregion
+export { nast2typst };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@nast/nast2typst",
+  "type": "module",
+  "version": "0.2.0",
+  "description": "Converts NAST (unified-like Notion Abstract Syntax Tree) to Typst markup language.",
+  "keywords": [
+    "notion",
+    "ast",
+    "unified",
+    "nast",
+    "typst",
+    "converter"
+  ],
+  "author": "Mapaor <pardo.marti@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/Mapaor/nast/tree/main/packages/nast2typst",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mapaor/nast.git",
+    "directory": "packages/nast2typst"
+  },
+  "bugs": {
+    "url": "https://github.com/Mapaor/nast/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index-CgBLzCnj.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "tex2typst": "^0.5.6"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "example": "tsx scripts/example.ts"
+  }
+}