feat:

Author: agoose77

packages/myst-cli/src/process/mdast.ts

@@ -67,6 +67,7 @@ import {
   transformFilterOutputStreams,
   transformLiftCodeBlocksInJupytext,
   transformMystXRefs,
+  liftOutputs,
 } from '../transforms/index.js';
 import type { ImageExtensions } from '../utils/resolveExtension.js';
 import { logMessagesFromVFile } from '../utils/logging.js';
@@ -240,6 +241,9 @@ export async function transformMdast(
 
   transformRenderInlineExpressions(mdast, vfile);
   await transformOutputsToCache(session, mdast, kind, { minifyMaxCharacters });
+  liftOutputs(session, mdast, vfile, {
+    parseMyst: (content: string) => parseMyst(session, content, file),
+  });
   transformFilterOutputStreams(mdast, vfile, frontmatter.settings);
   transformCitations(session, file, mdast, fileCitationRenderer, references);
   await unified()

packages/myst-cli/src/transforms/outputs.ts

@@ -12,7 +12,14 @@ import { selectAll } from 'unist-util-select';
 import type { VFile } from 'vfile';
 import type { IOutput, IStream } from '@jupyterlab/nbformat';
 import type { MinifiedContent, MinifiedOutput, MinifiedMimeOutput } from 'nbtx';
-import { ensureString, extFromMimeType, minifyCellOutput, walkOutputs } from 'nbtx';
+import {
+  convertToIOutputs,
+  ensureString,
+  extFromMimeType,
+  minifyCellOutput,
+  walkOutputs,
+} from 'nbtx';
+import { TexParser } from 'tex-to-myst';
 import { castSession } from '../session/cache.js';
 import type { ISession } from '../session/types.js';
 import { resolveOutputPath } from './images.js';
@@ -25,6 +32,82 @@ function getWriteDestination(hash: string, contentType: string, writeFolder: str
   return join(writeFolder, getFilename(hash, contentType));
 }
 
+const MARKDOWN_MIME_TYPE = 'text/markdown';
+const SUPPORTED_MARKDOWN_VARIANTS = ['Original', 'GFM', 'CommonMark', 'myst'];
+
+/**
+ * Extract the `variant` parameter from a Markdown MIME type
+ *
+ * @param mimeType MIME type of the form `text/markdown;FOO=BAR`
+ */
+function extractVariantParameter(mimeType: string): string | undefined {
+  const [variant] = Array.from(mimeType.matchAll(/;([^;]+)=([^;]+)/g))
+    .filter(([name]) => name === 'variant')
+    .map((pair) => pair[1]);
+  return variant;
+}
+
+/*
+ * Determine the Markdown variant from a given MIME-type
+ *
+ * If the MIME-type is not a supported Markdown MIME, return undefined
+ *
+ * @param mimeType - MIME type
+ */
+function determineMarkdownVariant(
+  mimeType: string,
+): { variant?: string; mimeType: string } | undefined {
+  if (!mimeType.startsWith(MARKDOWN_MIME_TYPE)) {
+    return;
+  }
+  const variant = extractVariantParameter(mimeType);
+  if (!variant) {
+    return { mimeType };
+  }
+  if (SUPPORTED_MARKDOWN_VARIANTS.includes(variant)) {
+    return { mimeType, variant };
+  }
+
+  return;
+}
+
+/**
+ * Lift outputs that contribute to the global document state
+ */
+export function liftOutputs(
+  session: ISession,
+  mdast: GenericParent,
+  vfile: VFile,
+  opts: { parseMyst: (source: string) => GenericParent },
+) {
+  const cache = castSession(session);
+  selectAll('output', mdast).forEach((output) => {
+    let children: GenericNode[] | undefined;
+    walkOutputs([(output as any).jupyter_data], (obj: any) => {
+      if (children) {
+        return;
+      }
+      const { content_type, content, hash } = obj;
+      const { mimeType: markdownMimeType } = determineMarkdownVariant(content_type) ?? {};
+      // Markdown output
+      if (markdownMimeType) {
+        const [cacheContent] = cache.$outputs[hash] ?? [];
+        const ast = opts.parseMyst(content ?? cacheContent);
+        children = ast.children;
+      }
+      // LaTeX (including math) output
+      else if (content_type === 'text/latex') {
+        const [cacheContent] = cache.$outputs[hash] ?? [];
+        const state = new TexParser(content ?? cacheContent, vfile);
+        children = state.ast.children;
+      }
+    });
+    if (children) {
+      (output as any).children = children;
+    }
+  });
+}
+
 /**
  * Traverse all output nodes, minify their content, and cache on the session
  */