Merge branch 'main' of github.com:quarto-dev/quarto-cli into main

Author: jjallaire

src/command/render/pandoc.ts

@@ -439,10 +439,16 @@ export async function runPandoc(
         }),
       );
 
-      const stagedTemplate = await stageTemplate(extras, options.temp, {
-        template,
-        partials,
-      });
+      // Stage the template and partials
+      const stagedTemplate = await stageTemplate(
+        options,
+        extras,
+        {
+          template,
+          partials,
+        },
+      );
+
       allDefaults[kTemplate] = stagedTemplate;
     } else {
       if (userPartials.length > 0) {

src/command/render/template.ts

@@ -5,14 +5,22 @@
 *
 */
 import { basename, join } from "path/mod.ts";
+import {
+  kHtmlMathMethod,
+  kSelfContained,
+  kSelfContainedMath,
+} from "../../config/constants.ts";
 
 import {
+  Format,
   FormatExtras,
   FormatTemplateContext,
   Metadata,
 } from "../../config/types.ts";
 import { copyTo } from "../../core/copy.ts";
-import { TempContext } from "../../core/temp.ts";
+import { PandocOptions, RenderFlags } from "./types.ts";
+import * as ld from "../../core/lodash.ts";
+import { isHtmlDocOutput, isRevealjsOutput } from "../../config/format.ts";
 
 export const kPatchedTemplateExt = ".patched";
 export const kTemplatePartials = "template-partials";
@@ -25,11 +33,11 @@ export function readPartials(metadata: Metadata) {
 }
 
 export async function stageTemplate(
+  options: PandocOptions,
   extras: FormatExtras,
-  temp: TempContext,
   userContext?: FormatTemplateContext,
 ) {
-  const stagingDir = temp.createDir();
+  const stagingDir = options.temp.createDir();
   const template = "template.patched";
 
   const stageContext = (
@@ -61,7 +69,14 @@ export async function stageTemplate(
   );
   const userStaged = await stageContext(stagingDir, template, userContext);
   if (formatStaged || userStaged) {
-    return join(stagingDir, template);
+    // The path to the newly staged template
+    const stagedTemplatePath = join(stagingDir, template);
+
+    // Apply any patches now that the template is staged
+    applyTemplatePatches(stagedTemplatePath, options.format, options.flags);
+
+    // Return the path to the template
+    return stagedTemplatePath;
   } else {
     return undefined;
   }
@@ -81,3 +96,136 @@ export function cleanTemplatePartialMetadata(
     }
   }
 }
+
+interface TemplatePatch {
+  searchValue: RegExp;
+  contents: string;
+}
+
+function applyTemplatePatches(
+  template: string,
+  format: Format,
+  flags?: RenderFlags,
+) {
+  // The patches to apply
+  const patches: TemplatePatch[] = [];
+
+  // make math evade self-contained for HTML and Reveal
+  if (isHtmlDocOutput(format.pandoc) || isRevealjsOutput(format.pandoc)) {
+    if (
+      ((flags && flags[kSelfContained]) || format.pandoc[kSelfContained]) &&
+      !format.render[kSelfContainedMath]
+    ) {
+      const math = mathConfig(format, flags);
+      if (math) {
+        const mathTemplate = math.method === "mathjax"
+          ? mathjaxScript(math.url)
+          : math.method == "katex"
+          ? katexScript(math.url)
+          : "";
+
+        if (mathTemplate) {
+          patches.push({
+            searchValue: /\$math\$/,
+            contents: mathTemplate,
+          });
+        }
+      }
+    }
+  }
+
+  // Apply any patches
+  if (patches.length) {
+    let templateContents = Deno.readTextFileSync(template);
+    patches.forEach((patch) => {
+      templateContents = templateContents.replace(
+        patch.searchValue,
+        patch.contents,
+      );
+    });
+    Deno.writeTextFileSync(template, templateContents);
+  }
+}
+
+function mathConfig(format: Format, flags?: RenderFlags) {
+  // if any command line math flags were passed then bail
+  if (
+    flags?.mathjax || flags?.katex || flags?.webtex || flags?.gladtex ||
+    flags?.mathml
+  ) {
+    return undefined;
+  }
+
+  const math = format.pandoc[kHtmlMathMethod];
+  if (math === undefined || math === "mathjax") {
+    return {
+      method: "mathjax",
+      url: "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml-full.js",
+    };
+  } else if (math === "katex") {
+    return {
+      method: "katex",
+      url: "https://cdn.jsdelivr.net/npm/[email protected]/dist/",
+    };
+  } else if (ld.isObject(math)) {
+    const mathMethod = math as { method: string; url: string };
+    if (
+      (mathMethod.method === "mathjax" || mathMethod.method === "katex") &&
+      typeof (mathMethod.url) === "string"
+    ) {
+      return mathMethod;
+    }
+  }
+}
+
+function mathjaxScript(url: string) {
+  return `
+  <script>
+    (function () {
+      var script = document.createElement("script");
+      script.type = "text/javascript";
+      script.src  = "${url}";
+      document.getElementsByTagName("head")[0].appendChild(script);
+    })();
+  </script>
+`;
+}
+
+function katexScript(url: string) {
+  url = url.trim();
+  if (!url.endsWith("/")) {
+    url += "/";
+  }
+  return `
+  <script>
+    document.addEventListener("DOMContentLoaded", function () {
+      var head = document.getElementsByTagName("head")[0];
+      var link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = "${url}katex.min.css";
+      head.appendChild(link);
+
+      var script = document.createElement("script");
+      script.type = "text/javascript";
+      script.src  = "${url}katex.min.js";
+      script.async = false;
+      script.addEventListener('load', function() {
+        var mathElements = document.getElementsByClassName("math");
+          var macros = [];
+          for (var i = 0; i < mathElements.length; i++) {
+            var texText = mathElements[i].firstChild;
+            if (mathElements[i].tagName == "SPAN") {
+              window.katex.render(texText.data, mathElements[i], {
+                displayMode: mathElements[i].classList.contains('display'),
+                throwOnError: false,
+                macros: macros,
+                fleqn: false
+              });
+            }
+          }
+      });
+      head.appendChild(script);
+    });
+  </script>
+  `;
+}

src/config/constants.ts

@@ -64,6 +64,7 @@ export const kTblCap = "tbl-cap";
 export const kTblColwidths = "tbl-colwidths";
 export const kMergeIncludes = "merge-includes";
 export const kPreferHtml = "prefer-html";
+export const kSelfContainedMath = "self-contained-math";
 
 export const kLatexAutoMk = "latex-auto-mk";
 export const kLatexAutoInstall = "latex-auto-install";
@@ -128,6 +129,7 @@ export const kRenderDefaultsKeys = [
   kCodeTools,
   kShortcodes,
   kTblColwidths,
+  kSelfContainedMath,
   kLatexAutoMk,
   kLatexAutoInstall,
   kLatexMinRuns,

src/config/types.ts

@@ -151,6 +151,7 @@ import {
   kSectionTitleReferences,
   kSectionTitleReuse,
   kSelfContained,
+  kSelfContainedMath,
   kShiftHeadingLevelBy,
   kShortcodes,
   kSlideLevel,
@@ -331,6 +332,7 @@ export interface FormatRender {
   [kLinkExternalIcon]?: string | boolean;
   [kLinkExternalNewwindow]?: boolean;
   [kLinkExternalFilter]?: string;
+  [kSelfContainedMath]?: boolean;
 }
 
 export interface FormatExecute {

src/format/formats-shared.ts

@@ -60,6 +60,7 @@ import {
   kPageWidth,
   kPreferHtml,
   kQuartoVersion,
+  kSelfContainedMath,
   kStandalone,
   kTblColwidths,
   kWarning,
@@ -219,6 +220,7 @@ function defaultFormat(): Format {
       [kLatexOutputDir]: null,
       [kLinkExternalIcon]: false,
       [kLinkExternalNewwindow]: false,
+      [kSelfContainedMath]: false,
     },
     pandoc: {},
     language: {},