@deepnote/convert 1.4.0 → 2.1.0

package/dist/src-oALQkXiP.js

@@ -0,0 +1,1485 @@
+import fs from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { createMarkdown, createPythonCode, deepnoteBlockSchema, deserializeDeepnoteFile, environmentSchema, executionSchema } from "@deepnote/blocks";
+import { v4 } from "uuid";
+import { parse, stringify } from "yaml";
+
+//#region src/utils.ts
+/**
+* Creates a sorting key for Deepnote blocks.
+* Uses a base-36 encoding to generate compact, sortable keys.
+*
+* @param index - The zero-based index of the block
+* @returns A sortable string key
+*/
+function createSortingKey(index) {
+	const maxLength = 6;
+	const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+	const base = 36;
+	if (index < 0) throw new Error("Index must be non-negative");
+	let result = "";
+	let num = index + 1;
+	let iterations = 0;
+	while (num > 0 && iterations < maxLength) {
+		num--;
+		result = chars[num % base] + result;
+		num = Math.floor(num / base);
+		iterations++;
+	}
+	if (num > 0) throw new Error(`Index ${index} exceeds maximum key length of ${maxLength}`);
+	return result;
+}
+/**
+* Sanitizes a filename by removing invalid characters and replacing spaces.
+*
+* @param name - The original filename
+* @returns A sanitized filename safe for all platforms
+*/
+function sanitizeFileName(name) {
+	return name.replace(/[<>:"/\\|?*]/g, "_").replace(/\s+/g, "_");
+}
+/**
+* Deepnote block types that should be converted to code cells.
+* Unknown types default to markdown (less lossy).
+*/
+const CODE_BLOCK_TYPES = [
+	"big-number",
+	"button",
+	"code",
+	"notebook-function",
+	"sql",
+	"visualization"
+];
+/**
+* Checks if a Deepnote block type should be converted to a markdown cell.
+* Uses a whitelist of code types and defaults unknown types to markdown (less lossy).
+*
+* @param blockType - The type of the Deepnote block
+* @returns true if the block should be treated as markdown
+*/
+function isMarkdownBlockType(blockType) {
+	if (blockType.startsWith("input-")) return false;
+	if (CODE_BLOCK_TYPES.includes(blockType)) return false;
+	return true;
+}
+/**
+* Sorts object keys alphabetically while preserving the type.
+* Useful for producing stable, predictable output in serialized formats like YAML.
+*
+* @param obj - The object whose keys should be sorted
+* @returns A new object with the same values but keys in alphabetical order
+*/
+function sortKeysAlphabetically(obj) {
+	const sorted = {};
+	for (const key of Object.keys(obj).sort()) sorted[key] = obj[key];
+	return sorted;
+}
+
+//#endregion
+//#region src/deepnote-to-jupyter.ts
+/**
+* Converts an array of Deepnote blocks into a single Jupyter Notebook.
+* This is the lowest-level conversion function, suitable for use in Deepnote Cloud.
+*
+* @param blocks - Array of DeepnoteBlock objects to convert
+* @param options - Notebook metadata options
+* @returns A JupyterNotebook object
+*
+* @example
+* ```typescript
+* import { convertBlocksToJupyterNotebook } from '@deepnote/convert'
+*
+* const notebook = convertBlocksToJupyterNotebook(blocks, {
+*   notebookId: 'abc123',
+*   notebookName: 'My Notebook',
+*   executionMode: 'block'
+* })
+* ```
+*/
+function convertBlocksToJupyterNotebook(blocks, options) {
+	return {
+		cells: blocks.map((block) => convertBlockToCell$3(block)),
+		metadata: {
+			deepnote_notebook_id: options.notebookId,
+			deepnote_notebook_name: options.notebookName,
+			deepnote_execution_mode: options.executionMode,
+			deepnote_is_module: options.isModule,
+			deepnote_working_directory: options.workingDirectory,
+			deepnote_environment: options.environment,
+			deepnote_execution: options.execution
+		},
+		nbformat: 4,
+		nbformat_minor: 0
+	};
+}
+/**
+* Converts a Deepnote project into Jupyter Notebook objects.
+* This is a pure conversion function that doesn't perform any file I/O.
+* Each notebook in the Deepnote project is converted to a separate Jupyter notebook.
+*
+* @param deepnoteFile - The deserialized Deepnote project file
+* @returns Array of objects containing filename and corresponding Jupyter notebook
+*
+* @example
+* ```typescript
+* import { deserializeDeepnoteFile } from '@deepnote/blocks'
+* import { convertDeepnoteToJupyterNotebooks } from '@deepnote/convert'
+*
+* const yamlContent = await fs.readFile('project.deepnote', 'utf-8')
+* const deepnoteFile = deserializeDeepnoteFile(yamlContent)
+* const notebooks = convertDeepnoteToJupyterNotebooks(deepnoteFile)
+*
+* for (const { filename, notebook } of notebooks) {
+*   console.log(`${filename}: ${notebook.cells.length} cells`)
+* }
+* ```
+*/
+function convertDeepnoteToJupyterNotebooks(deepnoteFile) {
+	return deepnoteFile.project.notebooks.map((notebook) => {
+		const jupyterNotebook = convertNotebookToJupyter(deepnoteFile, notebook);
+		return {
+			filename: `${sanitizeFileName(notebook.name)}.ipynb`,
+			notebook: jupyterNotebook
+		};
+	});
+}
+/**
+* Converts a Deepnote project file into separate Jupyter Notebook (.ipynb) files.
+* Each notebook in the Deepnote project becomes a separate .ipynb file.
+*/
+async function convertDeepnoteFileToJupyterFiles(deepnoteFilePath, options) {
+	const notebooks = convertDeepnoteToJupyterNotebooks(deserializeDeepnoteFile(await fs.readFile(deepnoteFilePath, "utf-8")));
+	await fs.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, notebook } of notebooks) {
+		const filePath = join(options.outputDir, filename);
+		await fs.writeFile(filePath, JSON.stringify(notebook, null, 2), "utf-8");
+	}
+}
+function convertBlockToCell$3(block) {
+	const content = block.content || "";
+	const jupyterCellType = convertBlockTypeToJupyter(block.type);
+	const executionStartedAt = "executionStartedAt" in block ? block.executionStartedAt : void 0;
+	const executionFinishedAt = "executionFinishedAt" in block ? block.executionFinishedAt : void 0;
+	const executionCount = "executionCount" in block ? block.executionCount : null;
+	const outputs = "outputs" in block ? block.outputs : void 0;
+	const metadata = {
+		...block.metadata || {},
+		cell_id: block.id,
+		deepnote_block_group: block.blockGroup,
+		deepnote_cell_type: block.type,
+		deepnote_sorting_key: block.sortingKey,
+		deepnote_content_hash: block.contentHash,
+		deepnote_execution_started_at: executionStartedAt,
+		deepnote_execution_finished_at: executionFinishedAt
+	};
+	metadata.deepnote_source = content;
+	return {
+		block_group: block.blockGroup,
+		cell_type: jupyterCellType,
+		execution_count: executionCount ?? null,
+		metadata,
+		outputs,
+		source: getSourceForBlock(block, jupyterCellType, content)
+	};
+}
+function getSourceForBlock(block, jupyterCellType, content) {
+	if (jupyterCellType === "markdown") return createMarkdown(block);
+	if (block.type === "code") return content;
+	return createPythonCode(block);
+}
+function convertBlockTypeToJupyter(blockType) {
+	return isMarkdownBlockType(blockType) ? "markdown" : "code";
+}
+function convertNotebookToJupyter(deepnoteFile, notebook) {
+	return convertBlocksToJupyterNotebook(notebook.blocks, {
+		notebookId: notebook.id,
+		notebookName: notebook.name,
+		executionMode: notebook.executionMode,
+		isModule: notebook.isModule,
+		workingDirectory: notebook.workingDirectory,
+		environment: deepnoteFile.environment,
+		execution: deepnoteFile.execution
+	});
+}
+
+//#endregion
+//#region src/deepnote-to-marimo.ts
+/** Current Marimo version for generated files */
+const MARIMO_VERSION = "0.10.0";
+/**
+* Converts an array of Deepnote blocks into a Marimo app.
+* This is the lowest-level conversion function.
+*
+* @param blocks - Array of DeepnoteBlock objects to convert
+* @param notebookName - Name of the notebook (used for app title)
+* @returns A MarimoApp object
+*/
+function convertBlocksToMarimoApp(blocks, notebookName) {
+	return {
+		generatedWith: MARIMO_VERSION,
+		width: "medium",
+		title: notebookName,
+		cells: blocks.map((block) => convertBlockToCell$2(block))
+	};
+}
+/**
+* Converts a Deepnote project into Marimo app objects.
+* This is a pure conversion function that doesn't perform any file I/O.
+* Each notebook in the Deepnote project is converted to a separate Marimo app.
+*
+* @param deepnoteFile - The deserialized Deepnote project file
+* @returns Array of objects containing filename and corresponding Marimo app
+*/
+function convertDeepnoteToMarimoApps(deepnoteFile) {
+	return deepnoteFile.project.notebooks.map((notebook) => {
+		const app = convertBlocksToMarimoApp(notebook.blocks, notebook.name);
+		return {
+			filename: `${sanitizeFileName(notebook.name)}.py`,
+			app
+		};
+	});
+}
+/**
+* Serializes a Marimo app to a Python file string.
+*
+* @param app - The Marimo app to serialize
+* @returns The serialized Python code string
+*/
+function serializeMarimoFormat(app) {
+	const lines = [];
+	const hasMarkdownOrSqlCells = app.cells.some((cell) => cell.cellType === "markdown" || cell.cellType === "sql");
+	if (hasMarkdownOrSqlCells) lines.push("import marimo as mo");
+	else lines.push("import marimo");
+	lines.push("");
+	lines.push(`__generated_with = "${app.generatedWith || MARIMO_VERSION}"`);
+	const appOptions = [];
+	if (app.width) appOptions.push(`width="${app.width}"`);
+	if (app.title) appOptions.push(`title="${escapeString(app.title)}"`);
+	const marimoRef = hasMarkdownOrSqlCells ? "mo" : "marimo";
+	const optionsStr = appOptions.length > 0 ? appOptions.join(", ") : "";
+	lines.push(`app = ${marimoRef}.App(${optionsStr})`);
+	lines.push("");
+	lines.push("");
+	for (const cell of app.cells) {
+		const decoratorOptions = [];
+		if (cell.hidden) decoratorOptions.push("hide_code=True");
+		if (cell.disabled) decoratorOptions.push("disabled=True");
+		const decoratorStr = decoratorOptions.length > 0 ? `@app.cell(${decoratorOptions.join(", ")})` : "@app.cell";
+		lines.push(decoratorStr);
+		const funcName = cell.functionName || "__";
+		const params = cell.dependencies?.join(", ") || "";
+		lines.push(`def ${funcName}(${params}):`);
+		if (cell.cellType === "markdown") {
+			const escaped = escapeTripleQuote(cell.content);
+			lines.push(`    mo.md(r"""`);
+			for (const contentLine of escaped.split("\n")) if (contentLine.trim() === "") lines.push("");
+			else lines.push(`    ${contentLine}`);
+			lines.push(`    """)`);
+			lines.push("    return");
+		} else if (cell.cellType === "sql") {
+			const escaped = escapeTripleQuote(cell.content);
+			const varName = cell.exports && cell.exports.length > 0 ? cell.exports[0] : "df";
+			const engineParam = cell.dependencies?.includes("engine") ? ", engine=engine" : "";
+			lines.push(`    ${varName} = mo.sql(`);
+			lines.push(`        f"""`);
+			for (const contentLine of escaped.split("\n")) if (contentLine === "" || contentLine.trim() === "") lines.push("");
+			else lines.push(`        ${contentLine}`);
+			lines.push(`        """${engineParam}`);
+			lines.push(`    )`);
+			if (cell.exports && cell.exports.length > 0) lines.push(`    return ${cell.exports.join(", ")},`);
+			else lines.push("    return");
+		} else {
+			const contentLines = cell.content.split("\n");
+			for (const contentLine of contentLines) if (contentLine.trim() === "") lines.push("");
+			else lines.push(`    ${contentLine}`);
+			if (cell.exports && cell.exports.length > 0) lines.push(`    return ${cell.exports.join(", ")},`);
+			else lines.push("    return");
+		}
+		lines.push("");
+		lines.push("");
+	}
+	lines.push("if __name__ == \"__main__\":");
+	lines.push("    app.run()");
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Converts a Deepnote project file into separate Marimo (.py) files.
+* Each notebook in the Deepnote project becomes a separate .py file.
+*/
+async function convertDeepnoteFileToMarimoFiles(deepnoteFilePath, options) {
+	const apps = convertDeepnoteToMarimoApps(deserializeDeepnoteFile(await fs.readFile(deepnoteFilePath, "utf-8")));
+	await fs.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, app } of apps) {
+		const filePath = join(options.outputDir, filename);
+		try {
+			const content = serializeMarimoFormat(app);
+			await fs.writeFile(filePath, content, "utf-8");
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			throw new Error(`Failed to write ${filename}: ${errorMessage}`, { cause: err });
+		}
+	}
+}
+function convertBlockToCell$2(block) {
+	const isMarkdown = isMarkdownBlockType(block.type);
+	const isSql = block.type === "sql";
+	const metadata = block.metadata || {};
+	let content;
+	let cellType;
+	if (isMarkdown) {
+		cellType = "markdown";
+		try {
+			content = createMarkdown(block);
+		} catch {
+			content = block.content || "";
+		}
+	} else if (isSql) {
+		cellType = "sql";
+		content = block.content || "";
+	} else if (block.type === "code") {
+		cellType = "code";
+		content = block.content || "";
+	} else {
+		cellType = "code";
+		try {
+			content = createPythonCode(block);
+		} catch {
+			content = block.content || "";
+		}
+	}
+	const dependencies = metadata.marimo_dependencies;
+	const exports = metadata.marimo_exports;
+	const hidden = metadata.is_code_hidden;
+	const disabled = metadata.marimo_disabled;
+	const functionName = metadata.marimo_function_name;
+	return {
+		cellType,
+		content,
+		...functionName ? { functionName } : {},
+		...dependencies && dependencies.length > 0 ? { dependencies } : {},
+		...exports && exports.length > 0 ? { exports } : {},
+		...hidden ? { hidden } : {},
+		...disabled ? { disabled } : {}
+	};
+}
+/**
+* Escapes a string for use in a Python double-quoted string literal.
+* Handles backslashes, quotes, control characters, and non-printable characters.
+*/
+function escapeString(str) {
+	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\x08]/g, "\\b").replace(/[\x0C]/g, "\\f").replace(/[\x00-\x07\x0B\x0E-\x1F\x7F-\x9F]/g, (char) => {
+		return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+	});
+}
+/**
+* Escapes content for use in a Python raw triple-quoted string (r""").
+* Raw strings don't interpret escape sequences, so we can't use backslashes to escape.
+* When we encounter triple quotes, we break the raw string and concatenate with a regular string.
+*/
+function escapeTripleQuote(str) {
+	return str.replace(/"""/g, "\"\"\"+'\"'+r\"\"\"");
+}
+
+//#endregion
+//#region src/deepnote-to-percent.ts
+/**
+* Converts an array of Deepnote blocks into a percent format notebook.
+* This is the lowest-level conversion function.
+*
+* @param blocks - Array of DeepnoteBlock objects to convert
+* @returns A PercentNotebook object
+*/
+function convertBlocksToPercentNotebook(blocks) {
+	return { cells: blocks.map((block) => convertBlockToCell$1(block)) };
+}
+/**
+* Converts a Deepnote project into percent format notebook objects.
+* This is a pure conversion function that doesn't perform any file I/O.
+* Each notebook in the Deepnote project is converted to a separate percent notebook.
+*
+* @param deepnoteFile - The deserialized Deepnote project file
+* @returns Array of objects containing filename and corresponding percent notebook
+*/
+function convertDeepnoteToPercentNotebooks(deepnoteFile) {
+	return deepnoteFile.project.notebooks.map((notebook) => {
+		const percentNotebook = convertBlocksToPercentNotebook(notebook.blocks);
+		return {
+			filename: `${sanitizeFileName(notebook.name)}.py`,
+			notebook: percentNotebook
+		};
+	});
+}
+/**
+* Serializes a percent format notebook to a string.
+*
+* @param notebook - The percent notebook to serialize
+* @returns The serialized percent format string
+*/
+function serializePercentFormat(notebook) {
+	const lines = [];
+	for (const cell of notebook.cells) {
+		let marker = "# %%";
+		if (cell.cellType === "markdown") marker += " [markdown]";
+		else if (cell.cellType === "raw") marker += " [raw]";
+		if (cell.title) marker += ` ${cell.title}`;
+		if (cell.tags && cell.tags.length > 0) {
+			const tagsStr = cell.tags.map((t) => JSON.stringify(t)).join(", ");
+			marker += ` tags=[${tagsStr}]`;
+		}
+		lines.push(marker);
+		if (cell.cellType === "markdown") {
+			const contentLines = cell.content.split("\n");
+			for (const contentLine of contentLines) if (contentLine === "") lines.push("#");
+			else lines.push(`# ${contentLine}`);
+		} else lines.push(cell.content);
+		lines.push("");
+	}
+	while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Converts a Deepnote project file into separate percent format (.py) files.
+* Each notebook in the Deepnote project becomes a separate .py file.
+*/
+async function convertDeepnoteFileToPercentFiles(deepnoteFilePath, options) {
+	const notebooks = convertDeepnoteToPercentNotebooks(deserializeDeepnoteFile(await fs.readFile(deepnoteFilePath, "utf-8")));
+	await fs.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, notebook } of notebooks) {
+		const filePath = join(options.outputDir, filename);
+		const content = serializePercentFormat(notebook);
+		await fs.writeFile(filePath, content, "utf-8");
+	}
+}
+function convertBlockToCell$1(block) {
+	const isMarkdown = isMarkdownBlockType(block.type);
+	let content;
+	if (isMarkdown) try {
+		content = createMarkdown(block);
+	} catch {
+		content = block.content || "";
+	}
+	else if (block.type === "code") content = block.content || "";
+	else try {
+		content = createPythonCode(block);
+	} catch {
+		content = block.content || "";
+	}
+	const title = block.metadata?.title;
+	const tags = block.metadata?.tags;
+	return {
+		cellType: block.metadata?.percent_cell_type === "raw" ? "raw" : isMarkdown ? "markdown" : "code",
+		content,
+		...title ? { title } : {},
+		...tags && tags.length > 0 ? { tags } : {}
+	};
+}
+
+//#endregion
+//#region src/deepnote-to-quarto.ts
+/**
+* Converts an array of Deepnote blocks into a Quarto document.
+* This is the lowest-level conversion function.
+*
+* @param blocks - Array of DeepnoteBlock objects to convert
+* @param notebookName - Name of the notebook (used for document title)
+* @returns A QuartoDocument object
+*/
+function convertBlocksToQuartoDocument(blocks, notebookName) {
+	const cells = blocks.map((block) => convertBlockToCell(block));
+	return {
+		frontmatter: {
+			title: notebookName,
+			jupyter: "python3"
+		},
+		cells
+	};
+}
+/**
+* Converts a Deepnote project into Quarto document objects.
+* This is a pure conversion function that doesn't perform any file I/O.
+* Each notebook in the Deepnote project is converted to a separate Quarto document.
+*
+* @param deepnoteFile - The deserialized Deepnote project file
+* @returns Array of objects containing filename and corresponding Quarto document
+*/
+function convertDeepnoteToQuartoDocuments(deepnoteFile) {
+	return deepnoteFile.project.notebooks.map((notebook) => {
+		const document = convertBlocksToQuartoDocument(notebook.blocks, notebook.name);
+		return {
+			filename: `${sanitizeFileName(notebook.name)}.qmd`,
+			document
+		};
+	});
+}
+/**
+* Serializes a Quarto document to a string.
+*
+* @param document - The Quarto document to serialize
+* @returns The serialized Quarto format string
+*/
+function serializeQuartoFormat(document) {
+	const lines = [];
+	if (document.frontmatter && Object.keys(document.frontmatter).length > 0) {
+		lines.push("---");
+		for (const [key, value] of Object.entries(document.frontmatter)) if (typeof value === "string") if (value.includes(":") || value.includes("#") || value.includes("'") || value.includes("\"")) lines.push(`${key}: "${value.replace(/"/g, "\\\"")}"`);
+		else lines.push(`${key}: ${value}`);
+		else if (typeof value === "boolean") lines.push(`${key}: ${value}`);
+		else if (value !== void 0) lines.push(`${key}: ${JSON.stringify(value)}`);
+		lines.push("---");
+		lines.push("");
+	}
+	let previousCellType = null;
+	for (const cell of document.cells) {
+		if (cell.cellType === "markdown") {
+			if (previousCellType === "markdown") {
+				lines.push("<!-- cell -->");
+				lines.push("");
+			}
+			lines.push(cell.content);
+			lines.push("");
+		} else {
+			const language = cell.language || "python";
+			lines.push(`\`\`\`{${language}}`);
+			if (cell.options) {
+				const optionLines = serializeQuartoCellOptions(cell.options);
+				lines.push(...optionLines);
+			}
+			lines.push(cell.content);
+			lines.push("```");
+			lines.push("");
+		}
+		previousCellType = cell.cellType;
+	}
+	while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Serializes Quarto cell options to #| format lines.
+*/
+function serializeQuartoCellOptions(options) {
+	const lines = [];
+	if (options.label) lines.push(`#| label: ${options.label}`);
+	if (options.echo !== void 0) lines.push(`#| echo: ${options.echo}`);
+	if (options.eval !== void 0) lines.push(`#| eval: ${options.eval}`);
+	if (options.output !== void 0) lines.push(`#| output: ${options.output}`);
+	if (options.figCap) lines.push(`#| fig-cap: "${options.figCap}"`);
+	if (options.figWidth !== void 0) lines.push(`#| fig-width: ${options.figWidth}`);
+	if (options.figHeight !== void 0) lines.push(`#| fig-height: ${options.figHeight}`);
+	if (options.tblCap) lines.push(`#| tbl-cap: "${options.tblCap}"`);
+	if (options.warning !== void 0) lines.push(`#| warning: ${options.warning}`);
+	if (options.message !== void 0) lines.push(`#| message: ${options.message}`);
+	if (options.raw) for (const [key, value] of Object.entries(options.raw)) if (typeof value === "string") lines.push(`#| ${key}: "${value}"`);
+	else lines.push(`#| ${key}: ${value}`);
+	return lines;
+}
+/**
+* Converts a Deepnote project file into separate Quarto (.qmd) files.
+* Each notebook in the Deepnote project becomes a separate .qmd file.
+*/
+async function convertDeepnoteFileToQuartoFiles(deepnoteFilePath, options) {
+	const documents = convertDeepnoteToQuartoDocuments(deserializeDeepnoteFile(await fs.readFile(deepnoteFilePath, "utf-8")));
+	await fs.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, document } of documents) {
+		const filePath = join(options.outputDir, filename);
+		const content = serializeQuartoFormat(document);
+		await fs.writeFile(filePath, content, "utf-8");
+	}
+}
+function convertBlockToCell(block) {
+	const isMarkdown = isMarkdownBlockType(block.type);
+	let content;
+	if (isMarkdown) try {
+		content = createMarkdown(block);
+	} catch {
+		content = block.content || "";
+	}
+	else if (block.type === "code") content = block.content || "";
+	else try {
+		content = createPythonCode(block);
+	} catch {
+		content = block.content || "";
+	}
+	let options;
+	const metadata = block.metadata || {};
+	if (metadata.quarto_label || metadata.is_code_hidden || metadata.quarto_fig_cap || metadata.quarto_tbl_cap) {
+		options = {};
+		if (metadata.quarto_label) options.label = metadata.quarto_label;
+		if (metadata.is_code_hidden) options.echo = false;
+		if (metadata.quarto_fig_cap) options.figCap = metadata.quarto_fig_cap;
+		if (metadata.quarto_tbl_cap) options.tblCap = metadata.quarto_tbl_cap;
+		if (metadata.quarto_options) options.raw = metadata.quarto_options;
+	}
+	const cell = {
+		cellType: isMarkdown ? "markdown" : "code",
+		content,
+		...options ? { options } : {}
+	};
+	if (metadata.language && metadata.language !== "python") cell.language = metadata.language;
+	return cell;
+}
+
+//#endregion
+//#region src/format-detection.ts
+/** Check if file content is Marimo format */
+function isMarimoContent(content) {
+	return /^import marimo\b/m.test(content) && /@app\.cell\b/.test(content) && !/^\s*['"]{3}[\s\S]*?import marimo/m.test(content);
+}
+/** Check if file content is percent format */
+function isPercentContent(content) {
+	return /^# %%/m.test(content) && !/^\s*['"]{3}[\s\S]*?# %%/m.test(content);
+}
+/**
+* Detects the notebook format from filename and optionally content.
+* For .py files, content is required to distinguish between Marimo and Percent formats.
+*/
+function detectFormat(filename, content) {
+	const lowercaseFilename = filename.toLowerCase();
+	if (lowercaseFilename.endsWith(".ipynb")) return "jupyter";
+	if (lowercaseFilename.endsWith(".deepnote")) return "deepnote";
+	if (lowercaseFilename.endsWith(".qmd")) return "quarto";
+	if (lowercaseFilename.endsWith(".py")) {
+		if (!content) throw new Error("Content is required to detect format for .py files");
+		if (isMarimoContent(content)) return "marimo";
+		if (isPercentContent(content)) return "percent";
+		throw new Error("Unsupported Python file format. File must be percent format (# %%) or Marimo (@app.cell).");
+	}
+	throw new Error(`Unsupported file format: ${filename}`);
+}
+
+//#endregion
+//#region src/jupyter-to-deepnote.ts
+/**
+* Converts a single Jupyter Notebook into an array of Deepnote blocks.
+* This is the lowest-level conversion function, suitable for use in Deepnote Cloud.
+*
+* @param notebook - The Jupyter notebook object to convert
+* @param options - Optional conversion options including custom ID generator
+* @returns Array of DeepnoteBlock objects
+*
+* @example
+* ```typescript
+* import { convertJupyterNotebookToBlocks } from '@deepnote/convert'
+*
+* const notebook = JSON.parse(ipynbContent)
+* const blocks = convertJupyterNotebookToBlocks(notebook, {
+*   idGenerator: () => myCustomIdGenerator()
+* })
+* ```
+*/
+function convertJupyterNotebookToBlocks(notebook, options) {
+	const idGenerator = options?.idGenerator ?? v4;
+	return notebook.cells.map((cell, index) => convertCellToBlock$3(cell, index, idGenerator));
+}
+/**
+* Converts Jupyter Notebook objects into a Deepnote project file.
+* This is a pure conversion function that doesn't perform any file I/O.
+*
+* @param notebooks - Array of Jupyter notebooks with filenames
+* @param options - Conversion options including project name
+* @returns A DeepnoteFile object
+*/
+function convertJupyterNotebooksToDeepnote(notebooks, options) {
+	let environment;
+	let execution;
+	for (const { notebook } of notebooks) {
+		if (!environment && notebook.metadata?.deepnote_environment) {
+			const parsed = environmentSchema.safeParse(notebook.metadata.deepnote_environment);
+			if (parsed.success) environment = parsed.data;
+		}
+		if (!execution && notebook.metadata?.deepnote_execution) {
+			const parsed = executionSchema.safeParse(notebook.metadata.deepnote_execution);
+			if (parsed.success) execution = parsed.data;
+		}
+	}
+	const firstNotebookId = notebooks.length > 0 ? notebooks[0].notebook.metadata?.deepnote_notebook_id ?? v4() : void 0;
+	const deepnoteFile = {
+		environment,
+		execution,
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: v4(),
+			initNotebookId: firstNotebookId,
+			integrations: [],
+			name: options.projectName,
+			notebooks: [],
+			settings: {}
+		},
+		version: "1.0.0"
+	};
+	for (let i = 0; i < notebooks.length; i++) {
+		const { filename, notebook } = notebooks[i];
+		const filenameWithoutExt = basename(filename, extname(filename)) || "Untitled notebook";
+		const blocks = convertJupyterNotebookToBlocks(notebook);
+		const notebookId = notebook.metadata?.deepnote_notebook_id;
+		const notebookName = notebook.metadata?.deepnote_notebook_name;
+		const executionMode = notebook.metadata?.deepnote_execution_mode;
+		const isModule = notebook.metadata?.deepnote_is_module;
+		const workingDirectory = notebook.metadata?.deepnote_working_directory;
+		const resolvedNotebookId = i === 0 && firstNotebookId ? firstNotebookId : notebookId ?? v4();
+		deepnoteFile.project.notebooks.push({
+			blocks,
+			executionMode: executionMode ?? "block",
+			id: resolvedNotebookId,
+			isModule: isModule ?? false,
+			name: notebookName ?? filenameWithoutExt,
+			workingDirectory
+		});
+	}
+	return deepnoteFile;
+}
+/**
+* Converts multiple Jupyter Notebook (.ipynb) files into a single Deepnote project file.
+*/
+async function convertIpynbFilesToDeepnoteFile(inputFilePaths, options) {
+	const notebooks = [];
+	for (const filePath of inputFilePaths) {
+		const notebook = await parseIpynbFile(filePath);
+		notebooks.push({
+			filename: basename(filePath),
+			notebook
+		});
+	}
+	const yamlContent = stringify(convertJupyterNotebooksToDeepnote(notebooks, { projectName: options.projectName }));
+	const parentDir = dirname(options.outputPath);
+	await fs.mkdir(parentDir, { recursive: true });
+	await fs.writeFile(options.outputPath, yamlContent, "utf-8");
+}
+async function parseIpynbFile(filePath) {
+	let ipynbJson;
+	try {
+		ipynbJson = await fs.readFile(filePath, "utf-8");
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to read ${filePath}: ${message}`);
+	}
+	try {
+		return JSON.parse(ipynbJson);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to parse ${filePath}: invalid JSON - ${message}`);
+	}
+}
+function convertCellToBlock$3(cell, index, idGenerator) {
+	let source = Array.isArray(cell.source) ? cell.source.join("") : cell.source;
+	const cellId = cell.metadata?.cell_id;
+	const deepnoteCellType = cell.metadata?.deepnote_cell_type;
+	const sortingKey = cell.metadata?.deepnote_sorting_key;
+	const contentHash = cell.metadata?.deepnote_content_hash;
+	const executionStartedAt = cell.metadata?.deepnote_execution_started_at;
+	const executionFinishedAt = cell.metadata?.deepnote_execution_finished_at;
+	const blockGroup = cell.metadata?.deepnote_block_group ?? cell.block_group ?? idGenerator();
+	const deepnoteSource = cell.metadata?.deepnote_source;
+	if (deepnoteSource !== void 0) source = deepnoteSource;
+	const blockType = deepnoteCellType ?? (cell.cell_type === "code" ? "code" : "markdown");
+	const originalMetadata = { ...cell.metadata };
+	delete originalMetadata.cell_id;
+	delete originalMetadata.deepnote_cell_type;
+	delete originalMetadata.deepnote_block_group;
+	delete originalMetadata.deepnote_sorting_key;
+	delete originalMetadata.deepnote_source;
+	delete originalMetadata.deepnote_content_hash;
+	delete originalMetadata.deepnote_execution_started_at;
+	delete originalMetadata.deepnote_execution_finished_at;
+	delete cell.block_group;
+	const executionCount = cell.execution_count ?? void 0;
+	const hasExecutionCount = executionCount !== void 0;
+	const hasOutputs = cell.cell_type === "code" && cell.outputs !== void 0;
+	return sortKeysAlphabetically(deepnoteBlockSchema.parse({
+		blockGroup,
+		content: source,
+		...contentHash ? { contentHash } : {},
+		...hasExecutionCount ? { executionCount } : {},
+		...executionFinishedAt ? { executionFinishedAt } : {},
+		...executionStartedAt ? { executionStartedAt } : {},
+		id: cellId ?? idGenerator(),
+		metadata: originalMetadata,
+		...hasOutputs ? { outputs: cell.outputs } : {},
+		sortingKey: sortingKey ?? createSortingKey(index),
+		type: blockType
+	}));
+}
+
+//#endregion
+//#region src/marimo-to-deepnote.ts
+/**
+* Splits a string on commas that are at the top level (not inside parentheses, brackets, braces, or string literals).
+* This handles cases like "func(a, b), other" and 'return "a,b", x' correctly.
+* Supports single quotes, double quotes, and backticks, with proper escape handling.
+*/
+function splitOnTopLevelCommas(str) {
+	const results = [];
+	let current = "";
+	let depth = 0;
+	let inString = null;
+	let escaped = false;
+	for (const char of str) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			if (inString === null) inString = char;
+			else if (inString === char) inString = null;
+			current += char;
+			continue;
+		}
+		if (inString !== null) {
+			current += char;
+			continue;
+		}
+		if (char === "(" || char === "[" || char === "{") {
+			depth++;
+			current += char;
+		} else if (char === ")" || char === "]" || char === "}") {
+			depth--;
+			current += char;
+		} else if (char === "," && depth === 0) {
+			results.push(current);
+			current = "";
+		} else current += char;
+	}
+	if (current) results.push(current);
+	return results;
+}
+/**
+* Parses a Marimo Python file into a MarimoApp structure.
+*
+* @param content - The raw content of the .py file
+* @returns A MarimoApp object
+*
+* @example
+* ```typescript
+* const content = `import marimo
+*
+* app = marimo.App()
+*
+* @app.cell
+* def __():
+*     print("hello")
+*     return
+* `
+* const app = parseMarimoFormat(content)
+* ```
+*/
+function parseMarimoFormat(content) {
+	const cells = [];
+	const generatedWith = /__generated_with\s*=\s*["']([^"']+)["']/.exec(content)?.[1];
+	const width = /(?:marimo|mo)\.App\([^)]*width\s*=\s*["']([^"']+)["']/.exec(content)?.[1];
+	const title = /(?:marimo|mo)\.App\([^)]*title\s*=\s*["']([^"']+)["']/.exec(content)?.[1];
+	const cellRegex = /@app\.cell(?:\(([^)]*)\))?\s*\n\s*def\s+(\w+)\s*\(([^)]*)\)\s*(?:->.*?)?\s*:\s*\n([\s\S]*?)(?=@app\.cell|if\s+__name__|$)/g;
+	let match = cellRegex.exec(content);
+	while (match !== null) {
+		const decoratorArgs = match[1] || "";
+		const functionName = match[2];
+		const params = match[3].trim();
+		let body = match[4];
+		const dependencies = params ? params.split(",").map((p) => p.trim()).filter((p) => p.length > 0) : void 0;
+		const hidden = /hide_code\s*=\s*True/.test(decoratorArgs);
+		const disabled = /disabled\s*=\s*True/.test(decoratorArgs);
+		const lines = body.split("\n");
+		const firstNonEmptyLine = lines.find((l) => l.trim().length > 0);
+		const baseIndent = (firstNonEmptyLine ? /^(\s*)/.exec(firstNonEmptyLine) : null)?.[1] || "";
+		let exports;
+		for (let i = lines.length - 1; i >= 0; i--) {
+			const line = lines[i];
+			if (line.startsWith(baseIndent) && !line.startsWith(`${baseIndent} `) && !line.startsWith(`${baseIndent}\t`)) {
+				const lineContent = line.slice(baseIndent.length);
+				const returnMatch = /^return\s*([^\n]*?)(?:,\s*)?$/.exec(lineContent);
+				if (returnMatch) {
+					const returnVal = returnMatch[1].trim();
+					if (returnVal && returnVal !== "None" && returnVal !== "") {
+						exports = splitOnTopLevelCommas(returnVal.replace(/^\(|\)$/g, "").replace(/,\s*$/, "")).map((e) => e.trim()).filter((e) => e.length > 0 && e !== "None");
+						if (exports.length === 0) exports = void 0;
+					}
+					break;
+				}
+			}
+		}
+		const filteredLines = lines.filter((line) => {
+			const normalizedLine = line.replace(/\t/g, "    ");
+			const normalizedBaseIndent = baseIndent.replace(/\t/g, "    ");
+			if (normalizedLine.startsWith(normalizedBaseIndent) && !normalizedLine.startsWith(`${normalizedBaseIndent} `) && !normalizedLine.startsWith(`${normalizedBaseIndent}\t`)) {
+				const lineContent = normalizedLine.slice(normalizedBaseIndent.length);
+				if (/^return\s*(?:[^\n]*)?(?:,\s*)?$/.test(lineContent)) return false;
+			}
+			return true;
+		});
+		let processedBody;
+		if (baseIndent.length > 0) processedBody = filteredLines.map((l) => l.startsWith(baseIndent) ? l.slice(baseIndent.length) : l).join("\n");
+		else processedBody = filteredLines.join("\n");
+		body = processedBody.trim();
+		const isMarkdown = /^\s*mo\.md\s*\(/.test(body) || /^\s*marimo\.md\s*\(/.test(body);
+		const isSql = /^\s*(?:\w+\s*=\s*)?(?:mo|marimo)\.sql\s*\(/.test(body);
+		if (isMarkdown) {
+			const mdMatch = /(?:mo|marimo)\.md\s*\(\s*(?:(?:r|f|rf|fr)?(?:"""([\s\S]*?)"""|'''([\s\S]*?)'''|"([^"]*)"|'([^']*)'))\s*\)/.exec(body);
+			if (mdMatch) {
+				const mdContent = mdMatch[1] || mdMatch[2] || mdMatch[3] || mdMatch[4] || "";
+				cells.push({
+					cellType: "markdown",
+					content: mdContent.trim(),
+					functionName,
+					...dependencies && dependencies.length > 0 ? { dependencies } : {},
+					...hidden ? { hidden } : {},
+					...disabled ? { disabled } : {}
+				});
+			}
+		} else if (isSql) {
+			const sqlMatch = /(?:mo|marimo)\.sql\s*\(\s*(?:f)?(?:"""([\s\S]*?)"""|'''([\s\S]*?)'''|"([^"]*)"|'([^']*)')\s*(?:,[\s\S]*)?\)/.exec(body);
+			if (sqlMatch) {
+				const sqlQuery = sqlMatch[1] || sqlMatch[2] || sqlMatch[3] || sqlMatch[4] || "";
+				cells.push({
+					cellType: "sql",
+					content: sqlQuery.trim(),
+					functionName,
+					...dependencies && dependencies.length > 0 ? { dependencies } : {},
+					...exports && exports.length > 0 ? { exports } : {},
+					...hidden ? { hidden } : {},
+					...disabled ? { disabled } : {}
+				});
+			}
+		} else cells.push({
+			cellType: "code",
+			content: body,
+			functionName,
+			...dependencies && dependencies.length > 0 ? { dependencies } : {},
+			...exports && exports.length > 0 ? { exports } : {},
+			...hidden ? { hidden } : {},
+			...disabled ? { disabled } : {}
+		});
+		match = cellRegex.exec(content);
+	}
+	return {
+		...generatedWith ? { generatedWith } : {},
+		...width ? { width } : {},
+		...title ? { title } : {},
+		cells
+	};
+}
+/**
+* Converts a single Marimo app into an array of Deepnote blocks.
+* This is the lowest-level conversion function.
+*
+* @param app - The Marimo app object to convert
+* @param options - Optional conversion options including custom ID generator
+* @returns Array of DeepnoteBlock objects
+*/
+function convertMarimoAppToBlocks(app, options) {
+	const idGenerator = options?.idGenerator ?? v4;
+	return app.cells.map((cell, index) => convertCellToBlock$2(cell, index, idGenerator));
+}
+/**
+* Converts Marimo app objects into a Deepnote project file.
+* This is a pure conversion function that doesn't perform any file I/O.
+*
+* @param apps - Array of Marimo apps with filenames
+* @param options - Conversion options including project name and optional ID generator
+* @returns A DeepnoteFile object
+*/
+function convertMarimoAppsToDeepnote(apps, options) {
+	const idGenerator = options.idGenerator ?? v4;
+	const firstNotebookId = apps.length > 0 ? idGenerator() : void 0;
+	const deepnoteFile = {
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: idGenerator(),
+			initNotebookId: firstNotebookId,
+			integrations: [],
+			name: options.projectName,
+			notebooks: [],
+			settings: {}
+		},
+		version: "1.0.0"
+	};
+	for (let i = 0; i < apps.length; i++) {
+		const { filename, app } = apps[i];
+		const filenameWithoutExt = basename(filename, extname(filename)) || "Untitled notebook";
+		const notebookName = app.title || filenameWithoutExt;
+		const blocks = convertMarimoAppToBlocks(app, { idGenerator });
+		const notebookId = i === 0 && firstNotebookId ? firstNotebookId : idGenerator();
+		deepnoteFile.project.notebooks.push({
+			blocks,
+			executionMode: "block",
+			id: notebookId,
+			isModule: false,
+			name: notebookName
+		});
+	}
+	return deepnoteFile;
+}
+/**
+* Converts multiple Marimo (.py) files into a single Deepnote project file.
+*/
+async function convertMarimoFilesToDeepnoteFile(inputFilePaths, options) {
+	const apps = [];
+	for (const filePath of inputFilePaths) try {
+		const app = parseMarimoFormat(await fs.readFile(filePath, "utf-8"));
+		apps.push({
+			filename: basename(filePath),
+			app
+		});
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		const errorStack = err instanceof Error ? err.stack : void 0;
+		throw new Error(`Failed to read or parse file ${basename(filePath)}: ${errorMessage}`, { cause: errorStack ? {
+			originalError: err,
+			stack: errorStack
+		} : err });
+	}
+	const yamlContent = stringify(convertMarimoAppsToDeepnote(apps, { projectName: options.projectName }));
+	const parentDir = dirname(options.outputPath);
+	await fs.mkdir(parentDir, { recursive: true });
+	await fs.writeFile(options.outputPath, yamlContent, "utf-8");
+}
+function convertCellToBlock$2(cell, index, idGenerator) {
+	let blockType;
+	if (cell.cellType === "markdown") blockType = "markdown";
+	else if (cell.cellType === "sql") blockType = "sql";
+	else blockType = "code";
+	const metadata = {};
+	if (cell.dependencies && cell.dependencies.length > 0) metadata.marimo_dependencies = cell.dependencies;
+	if (cell.exports && cell.exports.length > 0) metadata.marimo_exports = cell.exports;
+	if (cell.hidden) metadata.is_code_hidden = true;
+	if (cell.disabled) metadata.marimo_disabled = true;
+	if (cell.functionName && cell.functionName !== "__") metadata.marimo_function_name = cell.functionName;
+	if (cell.cellType === "sql" && cell.exports && cell.exports.length > 0) metadata.deepnote_variable_name = cell.exports[0];
+	return {
+		blockGroup: idGenerator(),
+		content: cell.content,
+		id: idGenerator(),
+		metadata: Object.keys(metadata).length > 0 ? metadata : {},
+		sortingKey: createSortingKey(index),
+		type: blockType
+	};
+}
+
+//#endregion
+//#region src/percent-to-deepnote.ts
+/**
+* Parses a percent format Python file into a PercentNotebook structure.
+*
+* @param content - The raw content of the .py file
+* @returns A PercentNotebook object
+*
+* @example
+* ```typescript
+* const content = `# %% [markdown]
+* # # My Title
+*
+* # %%
+* print("hello")
+* `
+* const notebook = parsePercentFormat(content)
+* ```
+*/
+function parsePercentFormat(content) {
+	const cells = [];
+	const lines = content.split("\n");
+	if (lines.length === 0 || lines.length === 1 && lines[0] === "") return { cells: [] };
+	const cellMarkerRegex = /^# %%\s*(?:\[(\w+)\])?\s*(.*)$/;
+	let currentCell = null;
+	let currentContent = [];
+	function finalizeCell() {
+		if (currentCell) {
+			if (currentCell.cellType === "markdown") currentCell.content = currentContent.map((line) => {
+				if (line.startsWith("# ")) return line.slice(2);
+				if (line === "#") return "";
+				return line;
+			}).join("\n").trim();
+			else currentCell.content = currentContent.join("\n").trim();
+			cells.push(currentCell);
+		}
+		currentContent = [];
+	}
+	for (const line of lines) {
+		const match = cellMarkerRegex.exec(line);
+		if (match) {
+			finalizeCell();
+			const cellTypeStr = match[1]?.toLowerCase() || "code";
+			const rest = match[2]?.trim() || "";
+			let cellType = "code";
+			if (cellTypeStr === "markdown" || cellTypeStr === "md") cellType = "markdown";
+			else if (cellTypeStr === "raw") cellType = "raw";
+			let title;
+			let tags;
+			const tagsMatch = /tags\s*=\s*\[([^\]]*)\]/.exec(rest);
+			if (tagsMatch) {
+				tags = tagsMatch[1].split(",").map((t) => t.trim().replace(/^["']|["']$/g, "")).filter((t) => t.length > 0);
+				const titlePart = rest.replace(/tags\s*=\s*\[[^\]]*\]/, "").trim();
+				if (titlePart) title = titlePart;
+			} else if (rest) title = rest;
+			currentCell = {
+				cellType,
+				content: "",
+				...title ? { title } : {},
+				...tags && tags.length > 0 ? { tags } : {}
+			};
+		} else if (currentCell) currentContent.push(line);
+		else if (line.trim() !== "" || currentContent.length > 0) {
+			currentCell = {
+				cellType: "code",
+				content: ""
+			};
+			currentContent.push(line);
+		}
+	}
+	finalizeCell();
+	return { cells };
+}
+/**
+* Converts a single percent format notebook into an array of Deepnote blocks.
+* This is the lowest-level conversion function.
+*
+* @param notebook - The percent notebook object to convert
+* @param options - Optional conversion options including custom ID generator
+* @returns Array of DeepnoteBlock objects
+*/
+function convertPercentNotebookToBlocks(notebook, options) {
+	const idGenerator = options?.idGenerator ?? v4;
+	return notebook.cells.map((cell, index) => convertCellToBlock$1(cell, index, idGenerator));
+}
+/**
+* Converts percent format notebook objects into a Deepnote project file.
+* This is a pure conversion function that doesn't perform any file I/O.
+*
+* @param notebooks - Array of percent notebooks with filenames
+* @param options - Conversion options including project name
+* @returns A DeepnoteFile object
+*/
+function convertPercentNotebooksToDeepnote(notebooks, options) {
+	const firstNotebookId = notebooks.length > 0 ? v4() : void 0;
+	const deepnoteFile = {
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: v4(),
+			initNotebookId: firstNotebookId,
+			integrations: [],
+			name: options.projectName,
+			notebooks: [],
+			settings: {}
+		},
+		version: "1.0.0"
+	};
+	for (let i = 0; i < notebooks.length; i++) {
+		const { filename, notebook } = notebooks[i];
+		const filenameWithoutExt = basename(filename, extname(filename)) || "Untitled notebook";
+		const blocks = convertPercentNotebookToBlocks(notebook);
+		const notebookId = i === 0 && firstNotebookId ? firstNotebookId : v4();
+		deepnoteFile.project.notebooks.push({
+			blocks,
+			executionMode: "block",
+			id: notebookId,
+			isModule: false,
+			name: filenameWithoutExt
+		});
+	}
+	return deepnoteFile;
+}
+/**
+* Converts multiple percent format (.py) files into a single Deepnote project file.
+*/
+async function convertPercentFilesToDeepnoteFile(inputFilePaths, options) {
+	const notebooks = [];
+	for (const filePath of inputFilePaths) {
+		const notebook = parsePercentFormat(await fs.readFile(filePath, "utf-8"));
+		notebooks.push({
+			filename: basename(filePath),
+			notebook
+		});
+	}
+	const yamlContent = stringify(convertPercentNotebooksToDeepnote(notebooks, { projectName: options.projectName }));
+	const parentDir = dirname(options.outputPath);
+	await fs.mkdir(parentDir, { recursive: true });
+	await fs.writeFile(options.outputPath, yamlContent, "utf-8");
+}
+function convertCellToBlock$1(cell, index, idGenerator) {
+	const blockType = cell.cellType === "markdown" || cell.cellType === "raw" ? "markdown" : "code";
+	const metadata = {};
+	if (cell.cellType === "raw") metadata.percent_cell_type = "raw";
+	if (cell.title) metadata.title = cell.title;
+	if (cell.tags && cell.tags.length > 0) metadata.tags = cell.tags;
+	return {
+		blockGroup: idGenerator(),
+		content: cell.content,
+		id: idGenerator(),
+		metadata: Object.keys(metadata).length > 0 ? metadata : {},
+		sortingKey: createSortingKey(index),
+		type: blockType
+	};
+}
+
+//#endregion
+//#region src/quarto-to-deepnote.ts
+/**
+* Parses a Quarto (.qmd) file into a QuartoDocument structure.
+*
+* @param content - The raw content of the .qmd file
+* @returns A QuartoDocument object
+*
+* @example
+* ```typescript
+* const content = `---
+* title: "My Document"
+* ---
+*
+* # Introduction
+*
+* \`\`\`{python}
+* print("hello")
+* \`\`\`
+* `
+* const doc = parseQuartoFormat(content)
+* ```
+*/
+function parseQuartoFormat(content) {
+	const cells = [];
+	let frontmatter;
+	let mainContent = content;
+	const frontmatterMatch = /^---\r?\n([\s\S]*?)---\r?\n?/.exec(content);
+	if (frontmatterMatch) {
+		frontmatter = parseYamlFrontmatter(frontmatterMatch[1]);
+		mainContent = content.slice(frontmatterMatch[0].length);
+	}
+	const codeChunkRegex = /```\{([\w-]+)\}\r?\n([\s\S]*?)```/g;
+	let lastIndex = 0;
+	let match = codeChunkRegex.exec(mainContent);
+	while (match !== null) {
+		const markdownBefore = mainContent.slice(lastIndex, match.index).trim();
+		if (markdownBefore) addMarkdownCells(cells, markdownBefore);
+		const language = match[1];
+		let codeContent = match[2];
+		const options = parseQuartoCellOptions(codeContent);
+		if (options) codeContent = codeContent.split("\n").filter((line) => !line.trimStart().startsWith("#|")).join("\n").trim();
+		else codeContent = codeContent.trim();
+		cells.push({
+			cellType: "code",
+			content: codeContent,
+			language,
+			...options ? { options } : {}
+		});
+		lastIndex = match.index + match[0].length;
+		match = codeChunkRegex.exec(mainContent);
+	}
+	const markdownAfter = mainContent.slice(lastIndex).trim();
+	if (markdownAfter) addMarkdownCells(cells, markdownAfter);
+	return {
+		...frontmatter ? { frontmatter } : {},
+		cells
+	};
+}
+/**
+* Splits markdown content at cell delimiter comments and adds each part as a separate cell.
+* The delimiter `<!-- cell -->` is used to preserve cell boundaries during roundtrip conversion.
+*/
+function addMarkdownCells(cells, content) {
+	const parts = content.split(/\s*<!--\s*cell\s*-->\s*/);
+	for (const part of parts) {
+		const trimmed = part.trim();
+		if (trimmed) cells.push({
+			cellType: "markdown",
+			content: trimmed
+		});
+	}
+}
+/**
+* Parses YAML frontmatter string into a QuartoFrontmatter object.
+* Uses the yaml package to properly handle nested objects, arrays, and all YAML features.
+*/
+function parseYamlFrontmatter(yamlString) {
+	if (!yamlString || yamlString.trim() === "") return {};
+	try {
+		const parsed = parse(yamlString);
+		if (parsed === null || parsed === void 0) return {};
+		if (typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+/**
+* Parses Quarto cell options from #| lines.
+*/
+function parseQuartoCellOptions(content) {
+	const optionLines = content.split("\n").filter((line) => line.trimStart().startsWith("#|"));
+	if (optionLines.length === 0) return;
+	const options = {};
+	const raw = {};
+	for (const line of optionLines) {
+		const match = /^#\|\s*(\S+):\s*(.*)$/.exec(line.trimStart());
+		if (match) {
+			const key = match[1];
+			let value = match[2].trim();
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			else if (value === "true") value = true;
+			else if (value === "false") value = false;
+			else {
+				const num = Number(value);
+				if (!Number.isNaN(num) && Number.isFinite(num)) value = num;
+			}
+			switch (key) {
+				case "label":
+					if (typeof value === "string") options.label = value;
+					else raw[key] = value;
+					break;
+				case "echo":
+					if (typeof value === "boolean") options.echo = value;
+					else if (value === "true" || value === "false") options.echo = value === "true";
+					else raw[key] = value;
+					break;
+				case "eval":
+					if (typeof value === "boolean") options.eval = value;
+					else if (value === "true" || value === "false") options.eval = value === "true";
+					else raw[key] = value;
+					break;
+				case "output":
+					if (typeof value === "boolean") options.output = value;
+					else if (value === "true" || value === "false") options.output = value === "true";
+					else raw[key] = value;
+					break;
+				case "fig-cap":
+					if (typeof value === "string") options.figCap = value;
+					else raw[key] = value;
+					break;
+				case "fig-width":
+					if (typeof value === "number" && Number.isFinite(value)) options.figWidth = value;
+					else if (typeof value === "string") {
+						const num = Number(value);
+						if (!Number.isNaN(num) && Number.isFinite(num)) options.figWidth = num;
+						else raw[key] = value;
+					} else raw[key] = value;
+					break;
+				case "fig-height":
+					if (typeof value === "number" && Number.isFinite(value)) options.figHeight = value;
+					else if (typeof value === "string") {
+						const num = Number(value);
+						if (!Number.isNaN(num) && Number.isFinite(num)) options.figHeight = num;
+						else raw[key] = value;
+					} else raw[key] = value;
+					break;
+				case "tbl-cap":
+					if (typeof value === "string") options.tblCap = value;
+					else raw[key] = value;
+					break;
+				case "warning":
+					if (typeof value === "boolean") options.warning = value;
+					else if (value === "true" || value === "false") options.warning = value === "true";
+					else raw[key] = value;
+					break;
+				case "message":
+					if (typeof value === "boolean") options.message = value;
+					else if (value === "true" || value === "false") options.message = value === "true";
+					else raw[key] = value;
+					break;
+				default: raw[key] = value;
+			}
+		}
+	}
+	if (Object.keys(raw).length > 0) options.raw = raw;
+	return Object.keys(options).length > 0 ? options : void 0;
+}
+/**
+* Converts a single Quarto document into an array of Deepnote blocks.
+* This is the lowest-level conversion function.
+*
+* @param document - The Quarto document object to convert
+* @param options - Optional conversion options including custom ID generator
+* @returns Array of DeepnoteBlock objects
+*/
+function convertQuartoDocumentToBlocks(document, options) {
+	const idGenerator = options?.idGenerator ?? v4;
+	const blocks = [];
+	if (document.frontmatter?.title) blocks.push({
+		blockGroup: idGenerator(),
+		content: `# ${document.frontmatter.title}`,
+		id: idGenerator(),
+		metadata: {},
+		sortingKey: createSortingKey(blocks.length),
+		type: "markdown"
+	});
+	for (const cell of document.cells) blocks.push(convertCellToBlock(cell, blocks.length, idGenerator));
+	return blocks;
+}
+/**
+* Converts Quarto document objects into a Deepnote project file.
+* This is a pure conversion function that doesn't perform any file I/O.
+*
+* @param documents - Array of Quarto documents with filenames
+* @param options - Conversion options including project name
+* @returns A DeepnoteFile object
+*/
+function convertQuartoDocumentsToDeepnote(documents, options) {
+	const firstNotebookId = documents.length > 0 ? v4() : void 0;
+	const deepnoteFile = {
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: v4(),
+			initNotebookId: firstNotebookId,
+			integrations: [],
+			name: options.projectName,
+			notebooks: [],
+			settings: {}
+		},
+		version: "1.0.0"
+	};
+	for (let i = 0; i < documents.length; i++) {
+		const { filename, document } = documents[i];
+		const filenameWithoutExt = basename(filename, extname(filename)) || "Untitled notebook";
+		const notebookName = document.frontmatter?.title || filenameWithoutExt;
+		const blocks = convertQuartoDocumentToBlocks(document);
+		const notebookId = i === 0 && firstNotebookId ? firstNotebookId : v4();
+		deepnoteFile.project.notebooks.push({
+			blocks,
+			executionMode: "block",
+			id: notebookId,
+			isModule: false,
+			name: typeof notebookName === "string" ? notebookName : filenameWithoutExt
+		});
+	}
+	return deepnoteFile;
+}
+/**
+* Converts multiple Quarto (.qmd) files into a single Deepnote project file.
+*/
+async function convertQuartoFilesToDeepnoteFile(inputFilePaths, options) {
+	const documents = [];
+	for (const filePath of inputFilePaths) {
+		const document = parseQuartoFormat(await fs.readFile(filePath, "utf-8"));
+		documents.push({
+			filename: basename(filePath),
+			document
+		});
+	}
+	const yamlContent = stringify(convertQuartoDocumentsToDeepnote(documents, { projectName: options.projectName }));
+	const parentDir = dirname(options.outputPath);
+	await fs.mkdir(parentDir, { recursive: true });
+	await fs.writeFile(options.outputPath, yamlContent, "utf-8");
+}
+function convertCellToBlock(cell, index, idGenerator) {
+	const blockType = cell.cellType === "markdown" ? "markdown" : "code";
+	const metadata = {};
+	if (cell.options) {
+		if (cell.options.label) metadata.quarto_label = cell.options.label;
+		if (cell.options.echo === false) metadata.is_code_hidden = true;
+		if (cell.options.figCap) metadata.quarto_fig_cap = cell.options.figCap;
+		if (cell.options.tblCap) metadata.quarto_tbl_cap = cell.options.tblCap;
+		if (cell.options.raw) metadata.quarto_options = cell.options.raw;
+	}
+	if (cell.language && cell.language !== "python") metadata.language = cell.language;
+	return {
+		blockGroup: idGenerator(),
+		content: cell.content,
+		id: idGenerator(),
+		metadata: Object.keys(metadata).length > 0 ? metadata : {},
+		sortingKey: createSortingKey(index),
+		type: blockType
+	};
+}
+
+//#endregion
+export { serializeMarimoFormat as A, convertBlocksToPercentNotebook as C, convertBlocksToMarimoApp as D, serializePercentFormat as E, convertDeepnoteFileToJupyterFiles as M, convertDeepnoteToJupyterNotebooks as N, convertDeepnoteFileToMarimoFiles as O, serializeQuartoFormat as S, convertDeepnoteToPercentNotebooks as T, isMarimoContent as _, convertPercentFilesToDeepnoteFile as a, convertDeepnoteFileToQuartoFiles as b, parsePercentFormat as c, convertMarimoFilesToDeepnoteFile as d, parseMarimoFormat as f, detectFormat as g, convertJupyterNotebooksToDeepnote as h, parseQuartoFormat as i, convertBlocksToJupyterNotebook as j, convertDeepnoteToMarimoApps as k, convertMarimoAppToBlocks as l, convertJupyterNotebookToBlocks as m, convertQuartoDocumentsToDeepnote as n, convertPercentNotebookToBlocks as o, convertIpynbFilesToDeepnoteFile as p, convertQuartoFilesToDeepnoteFile as r, convertPercentNotebooksToDeepnote as s, convertQuartoDocumentToBlocks as t, convertMarimoAppsToDeepnote as u, isPercentContent as v, convertDeepnoteFileToPercentFiles as w, convertDeepnoteToQuartoDocuments as x, convertBlocksToQuartoDocument as y };