@deepnote/convert 2.0.0 → 2.1.1

package/dist/src-DI6mrd_2.cjs

@@ -0,0 +1,1716 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let __deepnote_blocks = require("@deepnote/blocks");
+__deepnote_blocks = __toESM(__deepnote_blocks);
+let uuid = require("uuid");
+uuid = __toESM(uuid);
+let yaml = require("yaml");
+yaml = __toESM(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((0, __deepnote_blocks.deserializeDeepnoteFile)(await node_fs_promises.default.readFile(deepnoteFilePath, "utf-8")));
+	await node_fs_promises.default.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, notebook } of notebooks) {
+		const filePath = (0, node_path.join)(options.outputDir, filename);
+		await node_fs_promises.default.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 (0, __deepnote_blocks.createMarkdown)(block);
+	if (block.type === "code") return content;
+	return (0, __deepnote_blocks.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((0, __deepnote_blocks.deserializeDeepnoteFile)(await node_fs_promises.default.readFile(deepnoteFilePath, "utf-8")));
+	await node_fs_promises.default.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, app } of apps) {
+		const filePath = (0, node_path.join)(options.outputDir, filename);
+		try {
+			const content = serializeMarimoFormat(app);
+			await node_fs_promises.default.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 = (0, __deepnote_blocks.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 = (0, __deepnote_blocks.createPythonCode)(block);
+		} catch {
+			content = block.content || "";
+		}
+	}
+	const dependencies = metadata.marimo_dependencies;
+	const exports$1 = 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$1 && exports$1.length > 0 ? { exports: exports$1 } : {},
+		...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((0, __deepnote_blocks.deserializeDeepnoteFile)(await node_fs_promises.default.readFile(deepnoteFilePath, "utf-8")));
+	await node_fs_promises.default.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, notebook } of notebooks) {
+		const filePath = (0, node_path.join)(options.outputDir, filename);
+		const content = serializePercentFormat(notebook);
+		await node_fs_promises.default.writeFile(filePath, content, "utf-8");
+	}
+}
+function convertBlockToCell$1(block) {
+	const isMarkdown = isMarkdownBlockType(block.type);
+	let content;
+	if (isMarkdown) try {
+		content = (0, __deepnote_blocks.createMarkdown)(block);
+	} catch {
+		content = block.content || "";
+	}
+	else if (block.type === "code") content = block.content || "";
+	else try {
+		content = (0, __deepnote_blocks.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((0, __deepnote_blocks.deserializeDeepnoteFile)(await node_fs_promises.default.readFile(deepnoteFilePath, "utf-8")));
+	await node_fs_promises.default.mkdir(options.outputDir, { recursive: true });
+	for (const { filename, document } of documents) {
+		const filePath = (0, node_path.join)(options.outputDir, filename);
+		const content = serializeQuartoFormat(document);
+		await node_fs_promises.default.writeFile(filePath, content, "utf-8");
+	}
+}
+function convertBlockToCell(block) {
+	const isMarkdown = isMarkdownBlockType(block.type);
+	let content;
+	if (isMarkdown) try {
+		content = (0, __deepnote_blocks.createMarkdown)(block);
+	} catch {
+		content = block.content || "";
+	}
+	else if (block.type === "code") content = block.content || "";
+	else try {
+		content = (0, __deepnote_blocks.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 ?? uuid.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 = __deepnote_blocks.environmentSchema.safeParse(notebook.metadata.deepnote_environment);
+			if (parsed.success) environment = parsed.data;
+		}
+		if (!execution && notebook.metadata?.deepnote_execution) {
+			const parsed = __deepnote_blocks.executionSchema.safeParse(notebook.metadata.deepnote_execution);
+			if (parsed.success) execution = parsed.data;
+		}
+	}
+	const firstNotebookId = notebooks.length > 0 ? notebooks[0].notebook.metadata?.deepnote_notebook_id ?? (0, uuid.v4)() : void 0;
+	const deepnoteFile = {
+		environment,
+		execution,
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: (0, uuid.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 = (0, node_path.basename)(filename, (0, node_path.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 ?? (0, uuid.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: (0, node_path.basename)(filePath),
+			notebook
+		});
+	}
+	const yamlContent = (0, yaml.stringify)(convertJupyterNotebooksToDeepnote(notebooks, { projectName: options.projectName }));
+	const parentDir = (0, node_path.dirname)(options.outputPath);
+	await node_fs_promises.default.mkdir(parentDir, { recursive: true });
+	await node_fs_promises.default.writeFile(options.outputPath, yamlContent, "utf-8");
+}
+async function parseIpynbFile(filePath) {
+	let ipynbJson;
+	try {
+		ipynbJson = await node_fs_promises.default.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(__deepnote_blocks.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$1;
+		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$1 = splitOnTopLevelCommas(returnVal.replace(/^\(|\)$/g, "").replace(/,\s*$/, "")).map((e) => e.trim()).filter((e) => e.length > 0 && e !== "None");
+						if (exports$1.length === 0) exports$1 = 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$1 && exports$1.length > 0 ? { exports: exports$1 } : {},
+					...hidden ? { hidden } : {},
+					...disabled ? { disabled } : {}
+				});
+			}
+		} else cells.push({
+			cellType: "code",
+			content: body,
+			functionName,
+			...dependencies && dependencies.length > 0 ? { dependencies } : {},
+			...exports$1 && exports$1.length > 0 ? { exports: exports$1 } : {},
+			...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 ?? uuid.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 ?? uuid.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 = (0, node_path.basename)(filename, (0, node_path.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 node_fs_promises.default.readFile(filePath, "utf-8"));
+		apps.push({
+			filename: (0, node_path.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 ${(0, node_path.basename)(filePath)}: ${errorMessage}`, { cause: errorStack ? {
+			originalError: err,
+			stack: errorStack
+		} : err });
+	}
+	const yamlContent = (0, yaml.stringify)(convertMarimoAppsToDeepnote(apps, { projectName: options.projectName }));
+	const parentDir = (0, node_path.dirname)(options.outputPath);
+	await node_fs_promises.default.mkdir(parentDir, { recursive: true });
+	await node_fs_promises.default.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 ?? uuid.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 ? (0, uuid.v4)() : void 0;
+	const deepnoteFile = {
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: (0, uuid.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 = (0, node_path.basename)(filename, (0, node_path.extname)(filename)) || "Untitled notebook";
+		const blocks = convertPercentNotebookToBlocks(notebook);
+		const notebookId = i === 0 && firstNotebookId ? firstNotebookId : (0, uuid.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 node_fs_promises.default.readFile(filePath, "utf-8"));
+		notebooks.push({
+			filename: (0, node_path.basename)(filePath),
+			notebook
+		});
+	}
+	const yamlContent = (0, yaml.stringify)(convertPercentNotebooksToDeepnote(notebooks, { projectName: options.projectName }));
+	const parentDir = (0, node_path.dirname)(options.outputPath);
+	await node_fs_promises.default.mkdir(parentDir, { recursive: true });
+	await node_fs_promises.default.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 = (0, yaml.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 ?? uuid.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 ? (0, uuid.v4)() : void 0;
+	const deepnoteFile = {
+		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+		project: {
+			id: (0, uuid.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 = (0, node_path.basename)(filename, (0, node_path.extname)(filename)) || "Untitled notebook";
+		const notebookName = document.frontmatter?.title || filenameWithoutExt;
+		const blocks = convertQuartoDocumentToBlocks(document);
+		const notebookId = i === 0 && firstNotebookId ? firstNotebookId : (0, uuid.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 node_fs_promises.default.readFile(filePath, "utf-8"));
+		documents.push({
+			filename: (0, node_path.basename)(filePath),
+			document
+		});
+	}
+	const yamlContent = (0, yaml.stringify)(convertQuartoDocumentsToDeepnote(documents, { projectName: options.projectName }));
+	const parentDir = (0, node_path.dirname)(options.outputPath);
+	await node_fs_promises.default.mkdir(parentDir, { recursive: true });
+	await node_fs_promises.default.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
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'convertBlocksToJupyterNotebook', {
+  enumerable: true,
+  get: function () {
+    return convertBlocksToJupyterNotebook;
+  }
+});
+Object.defineProperty(exports, 'convertBlocksToMarimoApp', {
+  enumerable: true,
+  get: function () {
+    return convertBlocksToMarimoApp;
+  }
+});
+Object.defineProperty(exports, 'convertBlocksToPercentNotebook', {
+  enumerable: true,
+  get: function () {
+    return convertBlocksToPercentNotebook;
+  }
+});
+Object.defineProperty(exports, 'convertBlocksToQuartoDocument', {
+  enumerable: true,
+  get: function () {
+    return convertBlocksToQuartoDocument;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteFileToJupyterFiles', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteFileToJupyterFiles;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteFileToMarimoFiles', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteFileToMarimoFiles;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteFileToPercentFiles', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteFileToPercentFiles;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteFileToQuartoFiles', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteFileToQuartoFiles;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteToJupyterNotebooks', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteToJupyterNotebooks;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteToMarimoApps', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteToMarimoApps;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteToPercentNotebooks', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteToPercentNotebooks;
+  }
+});
+Object.defineProperty(exports, 'convertDeepnoteToQuartoDocuments', {
+  enumerable: true,
+  get: function () {
+    return convertDeepnoteToQuartoDocuments;
+  }
+});
+Object.defineProperty(exports, 'convertIpynbFilesToDeepnoteFile', {
+  enumerable: true,
+  get: function () {
+    return convertIpynbFilesToDeepnoteFile;
+  }
+});
+Object.defineProperty(exports, 'convertJupyterNotebookToBlocks', {
+  enumerable: true,
+  get: function () {
+    return convertJupyterNotebookToBlocks;
+  }
+});
+Object.defineProperty(exports, 'convertJupyterNotebooksToDeepnote', {
+  enumerable: true,
+  get: function () {
+    return convertJupyterNotebooksToDeepnote;
+  }
+});
+Object.defineProperty(exports, 'convertMarimoAppToBlocks', {
+  enumerable: true,
+  get: function () {
+    return convertMarimoAppToBlocks;
+  }
+});
+Object.defineProperty(exports, 'convertMarimoAppsToDeepnote', {
+  enumerable: true,
+  get: function () {
+    return convertMarimoAppsToDeepnote;
+  }
+});
+Object.defineProperty(exports, 'convertMarimoFilesToDeepnoteFile', {
+  enumerable: true,
+  get: function () {
+    return convertMarimoFilesToDeepnoteFile;
+  }
+});
+Object.defineProperty(exports, 'convertPercentFilesToDeepnoteFile', {
+  enumerable: true,
+  get: function () {
+    return convertPercentFilesToDeepnoteFile;
+  }
+});
+Object.defineProperty(exports, 'convertPercentNotebookToBlocks', {
+  enumerable: true,
+  get: function () {
+    return convertPercentNotebookToBlocks;
+  }
+});
+Object.defineProperty(exports, 'convertPercentNotebooksToDeepnote', {
+  enumerable: true,
+  get: function () {
+    return convertPercentNotebooksToDeepnote;
+  }
+});
+Object.defineProperty(exports, 'convertQuartoDocumentToBlocks', {
+  enumerable: true,
+  get: function () {
+    return convertQuartoDocumentToBlocks;
+  }
+});
+Object.defineProperty(exports, 'convertQuartoDocumentsToDeepnote', {
+  enumerable: true,
+  get: function () {
+    return convertQuartoDocumentsToDeepnote;
+  }
+});
+Object.defineProperty(exports, 'convertQuartoFilesToDeepnoteFile', {
+  enumerable: true,
+  get: function () {
+    return convertQuartoFilesToDeepnoteFile;
+  }
+});
+Object.defineProperty(exports, 'detectFormat', {
+  enumerable: true,
+  get: function () {
+    return detectFormat;
+  }
+});
+Object.defineProperty(exports, 'isMarimoContent', {
+  enumerable: true,
+  get: function () {
+    return isMarimoContent;
+  }
+});
+Object.defineProperty(exports, 'isPercentContent', {
+  enumerable: true,
+  get: function () {
+    return isPercentContent;
+  }
+});
+Object.defineProperty(exports, 'parseMarimoFormat', {
+  enumerable: true,
+  get: function () {
+    return parseMarimoFormat;
+  }
+});
+Object.defineProperty(exports, 'parsePercentFormat', {
+  enumerable: true,
+  get: function () {
+    return parsePercentFormat;
+  }
+});
+Object.defineProperty(exports, 'parseQuartoFormat', {
+  enumerable: true,
+  get: function () {
+    return parseQuartoFormat;
+  }
+});
+Object.defineProperty(exports, 'serializeMarimoFormat', {
+  enumerable: true,
+  get: function () {
+    return serializeMarimoFormat;
+  }
+});
+Object.defineProperty(exports, 'serializePercentFormat', {
+  enumerable: true,
+  get: function () {
+    return serializePercentFormat;
+  }
+});
+Object.defineProperty(exports, 'serializeQuartoFormat', {
+  enumerable: true,
+  get: function () {
+    return serializeQuartoFormat;
+  }
+});