@deepnote/convert 2.1.0 → 2.1.2

package/dist/index.d.cts

@@ -0,0 +1,633 @@
+import { DeepnoteBlock, DeepnoteFile, Environment, Execution } from "@deepnote/blocks";
+
+//#region src/types/jupyter.d.ts
+
+/**
+ * Shared Jupyter Notebook type definitions used by both
+ * deepnote-to-jupyter and jupyter-to-deepnote converters.
+ */
+interface JupyterCell {
+  /** Top-level block_group field present in cloud-exported notebooks */
+  block_group?: string;
+  cell_type: 'code' | 'markdown';
+  execution_count?: number | null;
+  metadata: JupyterCellMetadata;
+  outputs?: any[];
+  outputs_reference?: string;
+  source: string | string[];
+}
+interface JupyterCellMetadata {
+  cell_id?: string;
+  deepnote_cell_type?: string;
+  deepnote_block_group?: string;
+  deepnote_sorting_key?: string;
+  deepnote_source?: string;
+  [key: string]: unknown;
+}
+interface JupyterNotebook {
+  cells: JupyterCell[];
+  metadata: JupyterNotebookMetadata;
+  nbformat?: number;
+  nbformat_minor?: number;
+}
+interface JupyterNotebookMetadata {
+  deepnote_notebook_id?: string;
+  deepnote_notebook_name?: string;
+  deepnote_execution_mode?: 'block' | 'downstream';
+  deepnote_is_module?: boolean;
+  deepnote_working_directory?: string;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/deepnote-to-jupyter.d.ts
+interface ConvertDeepnoteFileToJupyterOptions {
+  outputDir: string;
+}
+interface ConvertBlocksToJupyterOptions {
+  /** Unique identifier for the notebook */
+  notebookId: string;
+  /** Display name of the notebook */
+  notebookName: string;
+  /** Execution mode: 'block' runs cells individually, 'downstream' runs dependent cells */
+  executionMode?: 'block' | 'downstream';
+  /** Whether this notebook is a module (importable by other notebooks) */
+  isModule?: boolean;
+  /** Working directory for the notebook */
+  workingDirectory?: string;
+  /** Environment snapshot metadata */
+  environment?: Environment;
+  /** Execution snapshot metadata */
+  execution?: Execution;
+}
+/**
+ * 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'
+ * })
+ * ```
+ */
+declare function convertBlocksToJupyterNotebook(blocks: DeepnoteBlock[], options: ConvertBlocksToJupyterOptions): JupyterNotebook;
+/**
+ * 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`)
+ * }
+ * ```
+ */
+declare function convertDeepnoteToJupyterNotebooks(deepnoteFile: DeepnoteFile): Array<{
+  filename: string;
+  notebook: JupyterNotebook;
+}>;
+/**
+ * Converts a Deepnote project file into separate Jupyter Notebook (.ipynb) files.
+ * Each notebook in the Deepnote project becomes a separate .ipynb file.
+ */
+declare function convertDeepnoteFileToJupyterFiles(deepnoteFilePath: string, options: ConvertDeepnoteFileToJupyterOptions): Promise<void>;
+//#endregion
+//#region src/types/marimo.d.ts
+/**
+ * Marimo (.py) format type definitions.
+ *
+ * Marimo is a reactive Python notebook that stores notebooks as pure Python files.
+ * Key characteristics:
+ * - Pure Python with @app.cell decorators
+ * - Reactive execution based on variable dependencies
+ * - Function signatures declare dependencies (def __(df): means "depends on df")
+ * - Return statements declare exports (return df, means "exports df")
+ *
+ * Example:
+ * ```python
+ * import marimo
+ *
+ * __generated_with = "0.8.0"
+ * app = marimo.App(width="medium")
+ *
+ * @app.cell
+ * def __():
+ *     import pandas as pd
+ *     return pd,
+ *
+ * @app.cell
+ * def __(pd):
+ *     df = pd.read_csv("data.csv")
+ *     return df,
+ *
+ * if __name__ == "__main__":
+ *     app.run()
+ * ```
+ */
+interface MarimoCell {
+  /** Cell type: 'code', 'markdown', or 'sql' */
+  cellType: 'code' | 'markdown' | 'sql';
+  /** Cell content (Python code, markdown text, or SQL query) */
+  content: string;
+  /** Function name (usually __ for anonymous cells) */
+  functionName?: string;
+  /** Variables this cell depends on (from function parameters) */
+  dependencies?: string[];
+  /** Variables this cell exports (from return statement) */
+  exports?: string[];
+  /** Whether this cell is hidden in the UI */
+  hidden?: boolean;
+  /** Whether this cell is disabled */
+  disabled?: boolean;
+}
+interface MarimoApp {
+  /** Marimo version that generated this file */
+  generatedWith?: string;
+  /** App width setting ('medium', 'full', etc.) */
+  width?: string;
+  /** Array of cells */
+  cells: MarimoCell[];
+  /** App title (from app.title if present) */
+  title?: string;
+}
+//#endregion
+//#region src/deepnote-to-marimo.d.ts
+interface ConvertDeepnoteFileToMarimoOptions {
+  outputDir: string;
+}
+/**
+ * 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
+ */
+declare function convertBlocksToMarimoApp(blocks: DeepnoteBlock[], notebookName: string): MarimoApp;
+/**
+ * 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
+ */
+declare function convertDeepnoteToMarimoApps(deepnoteFile: DeepnoteFile): Array<{
+  filename: string;
+  app: MarimoApp;
+}>;
+/**
+ * Serializes a Marimo app to a Python file string.
+ *
+ * @param app - The Marimo app to serialize
+ * @returns The serialized Python code string
+ */
+declare function serializeMarimoFormat(app: MarimoApp): string;
+/**
+ * Converts a Deepnote project file into separate Marimo (.py) files.
+ * Each notebook in the Deepnote project becomes a separate .py file.
+ */
+declare function convertDeepnoteFileToMarimoFiles(deepnoteFilePath: string, options: ConvertDeepnoteFileToMarimoOptions): Promise<void>;
+//#endregion
+//#region src/types/percent.d.ts
+/**
+ * Percent format (.py with # %%) type definitions.
+ *
+ * The percent format is a convention for representing notebooks as plain Python files.
+ * It's supported by VS Code, Spyder, PyCharm, JupyText, and Hydrogen.
+ *
+ * Cell markers:
+ * - `# %%` - Code cell
+ * - `# %% [markdown]` - Markdown cell
+ * - `# %% [raw]` - Raw cell
+ * - `# %% title` - Code cell with title
+ * - `# %% [markdown] title` - Markdown cell with title
+ * - `# %% tags=["a", "b"]` - Cell with tags
+ */
+interface PercentCell {
+  /** Cell type: 'code', 'markdown', or 'raw' */
+  cellType: 'code' | 'markdown' | 'raw';
+  /** Cell content (for markdown cells, this is without the '# ' prefix on each line) */
+  content: string;
+  /** Optional cell title */
+  title?: string;
+  /** Optional cell tags */
+  tags?: string[];
+  /** Additional metadata from the cell marker */
+  metadata?: Record<string, unknown>;
+}
+interface PercentNotebook {
+  /** Array of cells in the notebook */
+  cells: PercentCell[];
+  /** Optional file-level metadata (from first line comments) */
+  metadata?: {
+    /** Original filename */
+    filename?: string;
+  };
+}
+//#endregion
+//#region src/deepnote-to-percent.d.ts
+interface ConvertDeepnoteFileToPercentOptions {
+  outputDir: string;
+}
+/**
+ * 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
+ */
+declare function convertBlocksToPercentNotebook(blocks: DeepnoteBlock[]): PercentNotebook;
+/**
+ * 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
+ */
+declare function convertDeepnoteToPercentNotebooks(deepnoteFile: DeepnoteFile): Array<{
+  filename: string;
+  notebook: PercentNotebook;
+}>;
+/**
+ * Serializes a percent format notebook to a string.
+ *
+ * @param notebook - The percent notebook to serialize
+ * @returns The serialized percent format string
+ */
+declare function serializePercentFormat(notebook: PercentNotebook): string;
+/**
+ * Converts a Deepnote project file into separate percent format (.py) files.
+ * Each notebook in the Deepnote project becomes a separate .py file.
+ */
+declare function convertDeepnoteFileToPercentFiles(deepnoteFilePath: string, options: ConvertDeepnoteFileToPercentOptions): Promise<void>;
+//#endregion
+//#region src/types/quarto.d.ts
+/**
+ * Quarto (.qmd) format type definitions.
+ *
+ * Quarto is a next-generation publishing system for scientific and technical documents.
+ * It uses markdown with code chunks similar to R Markdown but is language-agnostic.
+ *
+ * Key elements:
+ * - YAML frontmatter for document metadata
+ * - Code chunks with ```{python} or ```{r} fencing
+ * - Cell options using #| syntax (e.g., #| label: my-chunk)
+ * - Rich markdown with special directives
+ */
+interface QuartoCell {
+  /** Cell type: 'code' or 'markdown' */
+  cellType: 'code' | 'markdown';
+  /** Cell content (code or markdown text) */
+  content: string;
+  /** Language for code cells (e.g., 'python', 'r') */
+  language?: string;
+  /** Cell options from #| lines */
+  options?: QuartoCellOptions;
+}
+interface QuartoCellOptions {
+  /** Cell label/identifier */
+  label?: string;
+  /** Whether to show the code in output */
+  echo?: boolean;
+  /** Whether to evaluate the code */
+  eval?: boolean;
+  /** Whether to show output */
+  output?: boolean;
+  /** Figure caption */
+  figCap?: string;
+  /** Figure width */
+  figWidth?: number;
+  /** Figure height */
+  figHeight?: number;
+  /** Table caption */
+  tblCap?: string;
+  /** Warning display setting */
+  warning?: boolean;
+  /** Message display setting */
+  message?: boolean;
+  /** Additional raw options */
+  raw?: Record<string, unknown>;
+}
+interface QuartoFrontmatter {
+  /** Document title */
+  title?: string;
+  /** Author(s) */
+  author?: string | string[];
+  /** Document date */
+  date?: string;
+  /** Output format(s) */
+  format?: string | Record<string, unknown>;
+  /** Jupyter kernel specification */
+  jupyter?: string;
+  /** Execute options */
+  execute?: {
+    echo?: boolean;
+    eval?: boolean;
+    warning?: boolean;
+    output?: boolean;
+  };
+  /** Additional metadata */
+  [key: string]: unknown;
+}
+interface QuartoDocument {
+  /** YAML frontmatter metadata */
+  frontmatter?: QuartoFrontmatter;
+  /** Array of cells (code chunks and markdown) */
+  cells: QuartoCell[];
+}
+//#endregion
+//#region src/deepnote-to-quarto.d.ts
+interface ConvertDeepnoteFileToQuartoOptions {
+  outputDir: string;
+}
+/**
+ * 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
+ */
+declare function convertBlocksToQuartoDocument(blocks: DeepnoteBlock[], notebookName: string): QuartoDocument;
+/**
+ * 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
+ */
+declare function convertDeepnoteToQuartoDocuments(deepnoteFile: DeepnoteFile): Array<{
+  filename: string;
+  document: QuartoDocument;
+}>;
+/**
+ * Serializes a Quarto document to a string.
+ *
+ * @param document - The Quarto document to serialize
+ * @returns The serialized Quarto format string
+ */
+declare function serializeQuartoFormat(document: QuartoDocument): string;
+/**
+ * Converts a Deepnote project file into separate Quarto (.qmd) files.
+ * Each notebook in the Deepnote project becomes a separate .qmd file.
+ */
+declare function convertDeepnoteFileToQuartoFiles(deepnoteFilePath: string, options: ConvertDeepnoteFileToQuartoOptions): Promise<void>;
+//#endregion
+//#region src/format-detection.d.ts
+type NotebookFormat = 'jupyter' | 'deepnote' | 'marimo' | 'percent' | 'quarto';
+/**
+ * Detects the notebook format from filename and optionally content.
+ * For .py files, content is required to distinguish between Marimo and Percent formats.
+ */
+declare function detectFormat(filename: string, content?: string): NotebookFormat;
+//#endregion
+//#region src/jupyter-to-deepnote.d.ts
+interface ConvertIpynbFilesToDeepnoteFileOptions {
+  outputPath: string;
+  projectName: string;
+}
+interface ConvertJupyterNotebookOptions {
+  /** Custom ID generator function. Defaults to uuid v4. */
+  idGenerator?: () => string;
+}
+interface JupyterNotebookInput {
+  filename: string;
+  notebook: JupyterNotebook;
+}
+/**
+ * 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()
+ * })
+ * ```
+ */
+declare function convertJupyterNotebookToBlocks(notebook: JupyterNotebook, options?: ConvertJupyterNotebookOptions): DeepnoteBlock[];
+/**
+ * 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
+ */
+declare function convertJupyterNotebooksToDeepnote(notebooks: JupyterNotebookInput[], options: {
+  projectName: string;
+}): DeepnoteFile;
+/**
+ * Converts multiple Jupyter Notebook (.ipynb) files into a single Deepnote project file.
+ */
+declare function convertIpynbFilesToDeepnoteFile(inputFilePaths: string[], options: ConvertIpynbFilesToDeepnoteFileOptions): Promise<void>;
+//#endregion
+//#region src/marimo-to-deepnote.d.ts
+interface ConvertMarimoFilesToDeepnoteFileOptions {
+  outputPath: string;
+  projectName: string;
+}
+interface ConvertMarimoAppOptions {
+  /** Custom ID generator function. Defaults to uuid v4. */
+  idGenerator?: () => string;
+}
+interface MarimoAppInput {
+  filename: string;
+  app: MarimoApp;
+}
+/**
+ * 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)
+ * ```
+ */
+declare function parseMarimoFormat(content: string): MarimoApp;
+/**
+ * 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
+ */
+declare function convertMarimoAppToBlocks(app: MarimoApp, options?: ConvertMarimoAppOptions): DeepnoteBlock[];
+interface ConvertMarimoAppsToDeepnoteOptions {
+  /** Project name for the Deepnote file */
+  projectName: string;
+  /** Custom ID generator function. Defaults to uuid v4. */
+  idGenerator?: () => string;
+}
+/**
+ * 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
+ */
+declare function convertMarimoAppsToDeepnote(apps: MarimoAppInput[], options: ConvertMarimoAppsToDeepnoteOptions): DeepnoteFile;
+/**
+ * Converts multiple Marimo (.py) files into a single Deepnote project file.
+ */
+declare function convertMarimoFilesToDeepnoteFile(inputFilePaths: string[], options: ConvertMarimoFilesToDeepnoteFileOptions): Promise<void>;
+//#endregion
+//#region src/percent-to-deepnote.d.ts
+interface ConvertPercentFilesToDeepnoteFileOptions {
+  outputPath: string;
+  projectName: string;
+}
+interface ConvertPercentNotebookOptions {
+  /** Custom ID generator function. Defaults to uuid v4. */
+  idGenerator?: () => string;
+}
+interface PercentNotebookInput {
+  filename: string;
+  notebook: PercentNotebook;
+}
+/**
+ * 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)
+ * ```
+ */
+declare function parsePercentFormat(content: string): PercentNotebook;
+/**
+ * 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
+ */
+declare function convertPercentNotebookToBlocks(notebook: PercentNotebook, options?: ConvertPercentNotebookOptions): DeepnoteBlock[];
+/**
+ * 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
+ */
+declare function convertPercentNotebooksToDeepnote(notebooks: PercentNotebookInput[], options: {
+  projectName: string;
+}): DeepnoteFile;
+/**
+ * Converts multiple percent format (.py) files into a single Deepnote project file.
+ */
+declare function convertPercentFilesToDeepnoteFile(inputFilePaths: string[], options: ConvertPercentFilesToDeepnoteFileOptions): Promise<void>;
+//#endregion
+//#region src/quarto-to-deepnote.d.ts
+interface ConvertQuartoFilesToDeepnoteFileOptions {
+  outputPath: string;
+  projectName: string;
+}
+interface ConvertQuartoDocumentOptions {
+  /** Custom ID generator function. Defaults to uuid v4. */
+  idGenerator?: () => string;
+}
+interface QuartoDocumentInput {
+  filename: string;
+  document: QuartoDocument;
+}
+/**
+ * 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)
+ * ```
+ */
+declare function parseQuartoFormat(content: string): QuartoDocument;
+/**
+ * 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
+ */
+declare function convertQuartoDocumentToBlocks(document: QuartoDocument, options?: ConvertQuartoDocumentOptions): DeepnoteBlock[];
+/**
+ * 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
+ */
+declare function convertQuartoDocumentsToDeepnote(documents: QuartoDocumentInput[], options: {
+  projectName: string;
+}): DeepnoteFile;
+/**
+ * Converts multiple Quarto (.qmd) files into a single Deepnote project file.
+ */
+declare function convertQuartoFilesToDeepnoteFile(inputFilePaths: string[], options: ConvertQuartoFilesToDeepnoteFileOptions): Promise<void>;
+//#endregion
+export { type ConvertBlocksToJupyterOptions, type ConvertDeepnoteFileToMarimoOptions, type ConvertDeepnoteFileToPercentOptions, type ConvertDeepnoteFileToQuartoOptions, type ConvertIpynbFilesToDeepnoteFileOptions, type ConvertJupyterNotebookOptions, type ConvertMarimoAppOptions, type ConvertMarimoAppsToDeepnoteOptions, type ConvertMarimoFilesToDeepnoteFileOptions, type ConvertPercentFilesToDeepnoteFileOptions, type ConvertPercentNotebookOptions, type ConvertQuartoDocumentOptions, type ConvertQuartoFilesToDeepnoteFileOptions, type JupyterCell, type JupyterNotebook, type JupyterNotebookInput, type MarimoApp, type MarimoAppInput, type MarimoCell, type NotebookFormat, type PercentCell, type PercentNotebook, type PercentNotebookInput, type QuartoCell, type QuartoCellOptions, type QuartoDocument, type QuartoDocumentInput, type QuartoFrontmatter, convertBlocksToJupyterNotebook, convertBlocksToMarimoApp, convertBlocksToPercentNotebook, convertBlocksToQuartoDocument, convertDeepnoteFileToJupyterFiles as convertDeepnoteFileToJupyter, convertDeepnoteFileToMarimoFiles, convertDeepnoteFileToPercentFiles, convertDeepnoteFileToQuartoFiles, convertDeepnoteToJupyterNotebooks, convertDeepnoteToMarimoApps, convertDeepnoteToPercentNotebooks, convertDeepnoteToQuartoDocuments, convertIpynbFilesToDeepnoteFile, convertJupyterNotebookToBlocks, convertJupyterNotebooksToDeepnote, convertMarimoAppToBlocks, convertMarimoAppsToDeepnote, convertMarimoFilesToDeepnoteFile, convertPercentFilesToDeepnoteFile, convertPercentNotebookToBlocks, convertPercentNotebooksToDeepnote, convertQuartoDocumentToBlocks, convertQuartoDocumentsToDeepnote, convertQuartoFilesToDeepnoteFile, detectFormat, parseMarimoFormat, parsePercentFormat, parseQuartoFormat, serializeMarimoFormat, serializePercentFormat, serializeQuartoFormat };