@quarto/jupyterlab-quarto 0.1.45 → 0.2.4

package/lib/plugins/gridtables/common/markdown-it/EmitTable.js

@@ -2,8 +2,8 @@
  *  Copyright (c) Bas Verweij. All rights reserved.
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import getCells from "../gridtables/GetCells";
-import ColumnAlignments from "./ColumnAlignments";
+import getCells from '../gridtables/GetCells';
+import ColumnAlignments from './ColumnAlignments';
 export default function emitTable(md, state, result) {
     let offsets = result.SeparatorLineOffsets;
     let token = state.push('table_open', 'table', 1);
@@ -21,42 +21,40 @@ export default function emitTable(md, state, result) {
     token = state.push('tbody_open', 'tbody', 1);
     token.map = [offsets[0], offsets[offsets.length - 1]];
     for (let i = 0; i < result.RowLines.length; i++) {
-        let cells = getCells(result.RowLines[i]);
+        const cells = getCells(result.RowLines[i]);
         processRow(md, state, 'td', result.ColumnAlignments, offsets[i], offsets[i + 1], cells);
     }
     state.push('tbody_close', 'tbody', -1);
     state.push('table_close', 'table', -1);
 }
 function processRow(md, state, tag, columnAlignments, lineBegin, lineEnd, cells) {
-    let token = state.push('tr_open', 'tr', 1);
+    const token = state.push('tr_open', 'tr', 1);
     token.map = [lineBegin, lineEnd];
     for (let i = 0; i < cells.length; i++) {
-        let token = state.push(tag + '_open', tag, 1);
+        const token = state.push(tag + '_open', tag, 1);
         token.map = [lineBegin + 1, lineEnd - 1];
         if (columnAlignments[i] !== ColumnAlignments.None) {
-            token.attrSet("style", `text-align: ${columnAlignments[i]};`);
+            token.attrSet('style', `text-align: ${columnAlignments[i]};`);
         }
         if (cells[i].length === 0) {
             // empty cell
         }
         else if (cells[i].length === 1) {
             // single line cell -> emit as inline markdown
-            let token = state.push('inline', '', 0);
+            const token = state.push('inline', '', 0);
             token.content = cells[i][0].trim();
             token.children = [];
         }
         else {
             // multi line cell -> render and emit as html
-            let cell = md
-                .render(cells[i].join('\r\n'))
-                .trim();
+            let cell = md.render(cells[i].join('\r\n')).trim();
             // remove single p tag because we're in a table cell
-            if ((cell.slice(0, 3) === '<p>') &&
-                (cell.slice(-4) === '</p>') &&
-                (cell.indexOf('<p>', 3) === -1)) {
+            if (cell.slice(0, 3) === '<p>' &&
+                cell.slice(-4) === '</p>' &&
+                cell.indexOf('<p>', 3) === -1) {
                 cell = cell.slice(3, cell.length - 4);
             }
-            let token = state.push('html_block', '', 0);
+            const token = state.push('html_block', '', 0);
             token.content = cell;
             token.children = [];
         }
@@ -64,4 +62,3 @@ function processRow(md, state, tag, columnAlignments, lineBegin, lineEnd, cells)
     }
     state.push('tr_close', 'tr', -1);
 }
-//# sourceMappingURL=EmitTable.js.map

package/lib/plugins/gridtables/common/markdown-it/GetCharCodeAtStartOfLine.d.ts

@@ -1,4 +1,4 @@
-import IState from "../../interfaces/markdown-it/IState";
+import IState from '../../interfaces/markdown-it/IState';
 /**
  * Returns the char code of the character at the start of the current line,
  * or -1 if this is not available (e.g. on an empty line).
@@ -6,4 +6,3 @@ import IState from "../../interfaces/markdown-it/IState";
  * @param state The Markdown It state.
  */
 export default function getCharCodeAtStartOfLine(state: IState, line: number): number;
-//# sourceMappingURL=GetCharCodeAtStartOfLine.d.ts.map

package/lib/plugins/gridtables/common/markdown-it/GetCharCodeAtStartOfLine.js

@@ -9,11 +9,9 @@
  * @param state The Markdown It state.
  */
 export default function getCharCodeAtStartOfLine(state, line) {
-    const pos = state.bMarks[line] +
-        state.tShift[line];
+    const pos = state.bMarks[line] + state.tShift[line];
     if (pos >= state.eMarks[line]) {
         return -1;
     }
     return state.src.charCodeAt(pos);
 }
-//# sourceMappingURL=GetCharCodeAtStartOfLine.js.map

package/lib/plugins/gridtables/common/markdown-it/GetLine.d.ts

@@ -1,3 +1,2 @@
-import IState from "../../interfaces/markdown-it/IState";
+import IState from '../../interfaces/markdown-it/IState';
 export default function getLine(state: IState, line: number): string;
-//# sourceMappingURL=GetLine.d.ts.map

package/lib/plugins/gridtables/common/markdown-it/GetLine.js

@@ -7,4 +7,3 @@ export default function getLine(state, line) {
     const end = state.eMarks[line];
     return state.src.substr(start, end - start);
 }
-//# sourceMappingURL=GetLine.js.map

package/lib/plugins/gridtables/common/markdown-it/ParseTable.d.ts

@@ -1,4 +1,3 @@
-import IState from "../../interfaces/markdown-it/IState";
-import ParseTableResult from "./ParseTableResult";
+import IState from '../../interfaces/markdown-it/IState';
+import ParseTableResult from './ParseTableResult';
 export default function parseTable(state: IState, startLine: number, endLine: number): ParseTableResult;
-//# sourceMappingURL=ParseTable.d.ts.map

package/lib/plugins/gridtables/common/markdown-it/ParseTable.js

@@ -2,11 +2,11 @@
  *  Copyright (c) Bas Verweij. All rights reserved.
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import wcwidth from "wcwidth";
-import getColumnWidths from "../gridtables/GetColumnWidths";
-import ColumnAlignments from "./ColumnAlignments";
-import getLine from "./GetLine";
-import ParseTableResult from "./ParseTableResult";
+import wcwidth from 'wcwidth';
+import getColumnWidths from '../gridtables/GetColumnWidths';
+import ColumnAlignments from './ColumnAlignments';
+import getLine from './GetLine';
+import ParseTableResult from './ParseTableResult';
 export default function parseTable(state, startLine, endLine) {
     const result = new ParseTableResult();
     let rowLine = getLine(state, startLine);
@@ -20,8 +20,7 @@ export default function parseTable(state, startLine, endLine) {
         return result;
     }
     // initialize column alignments
-    result.ColumnAlignments = result.ColumnWidths
-        .map(_ => ColumnAlignments.None);
+    result.ColumnAlignments = result.ColumnWidths.map(() => ColumnAlignments.None);
     if (rowLine.indexOf(':') >= 0) {
         // column alignment specifiers present in first row line
         result.HeaderLess = true;
@@ -32,21 +31,16 @@ export default function parseTable(state, startLine, endLine) {
     }
     // create header line matcher
     const headerLineMatcher = new RegExp('^\\+' +
-        result.ColumnWidths
-            .map(w => `[=:][=]{${w - 3}}[=:]\\+`)
-            .join('') +
+        result.ColumnWidths.map(w => `[=:][=]{${w - 3}}[=:]\\+`).join('') +
         '$');
     // build column offsets
     result.ColumnOffsets = [0];
     for (let i = 0; i < result.ColumnWidths.length - 1; i++) {
-        result.ColumnOffsets.push(result.ColumnOffsets[i] +
-            result.ColumnWidths[i]);
+        result.ColumnOffsets.push(result.ColumnOffsets[i] + result.ColumnWidths[i]);
     }
     // create cell line matcher
     const cellLineMatcher = new RegExp('^\\|' +
-        result.ColumnWidths
-            .map(w => `([^|]{${Math.ceil((w - 1) / 2)},${w - 1}})\\|`)
-            .join('') +
+        result.ColumnWidths.map(w => `([^|]{${Math.ceil((w - 1) / 2)},${w - 1}})\\|`).join('') +
         '$');
     // save first separator line offset
     result.SeparatorLineOffsets.push(startLine);
@@ -55,8 +49,8 @@ export default function parseTable(state, startLine, endLine) {
     let currentLine = startLine + 1;
     for (; currentLine <= endLine; currentLine++) {
         const line = getLine(state, currentLine);
-        if (line.charCodeAt(0) === 0x2B) // '+'
-         {
+        if (line.charCodeAt(0) === 0x2b) {
+            // '+'
             // separator line
             if (currentRow.length === 0) {
                 // no row lines since last separator -> invalid table
@@ -71,11 +65,9 @@ export default function parseTable(state, startLine, endLine) {
                     result.HeaderLess = true;
                 }
             }
-            else if (!result.HeaderLess &&
-                line.match(headerLineMatcher)) {
+            else if (!result.HeaderLess && line.match(headerLineMatcher)) {
                 // found header line
-                if (result.HeaderLines.length > 0 ||
-                    result.RowLines.length > 0) {
+                if (result.HeaderLines.length > 0 || result.RowLines.length > 0) {
                     // header already found, or not the first row -> invalid table
                     return result;
                 }
@@ -93,8 +85,8 @@ export default function parseTable(state, startLine, endLine) {
             // reset current row
             currentRow = [];
         }
-        else if (line.charCodeAt(0) === 0x7C) // '|'
-         {
+        else if (line.charCodeAt(0) === 0x7c) {
+            // '|'
             // cell line
             const matches = line.match(cellLineMatcher);
             if (matches === null) {
@@ -112,8 +104,7 @@ export default function parseTable(state, startLine, endLine) {
         else {
             // not a separator or cell line, check if we have a complete table
             if (currentRow.length === 0 &&
-                ((result.HeaderLines.length > 0) ||
-                    (result.RowLines.length > 0))) {
+                (result.HeaderLines.length > 0 || result.RowLines.length > 0)) {
                 // found a complete table
                 break;
             }
@@ -125,7 +116,7 @@ export default function parseTable(state, startLine, endLine) {
     return result;
 }
 function getColumnAlignments(line, columnWidths) {
-    let alignments = [];
+    const alignments = [];
     let left = 1;
     let right = -1;
     for (let i = 0; i < columnWidths.length; i++) {
@@ -149,7 +140,7 @@ function getColumnAlignments(line, columnWidths) {
 }
 function validateColumnWidths(matches, columnWidths) {
     const cells = [];
-    for (var i = 0; i < columnWidths.length; i++) {
+    for (let i = 0; i < columnWidths.length; i++) {
         const cell = matches[i + 1];
         const columnWidth = wcwidth(cell) + 1; // add 1 for separator
         if (columnWidth !== columnWidths[i]) {
@@ -159,4 +150,3 @@ function validateColumnWidths(matches, columnWidths) {
     }
     return cells;
 }
-//# sourceMappingURL=ParseTable.js.map

package/lib/plugins/gridtables/common/markdown-it/ParseTableResult.d.ts

@@ -1,4 +1,4 @@
-import ColumnAlignments from "./ColumnAlignments";
+import ColumnAlignments from './ColumnAlignments';
 export default class ParseTableResult {
     Success: boolean;
     ColumnWidths: number[];
@@ -10,4 +10,3 @@ export default class ParseTableResult {
     SeparatorLineOffsets: number[];
     CurrentLine: number;
 }
-//# sourceMappingURL=ParseTableResult.d.ts.map

package/lib/plugins/gridtables/common/markdown-it/ParseTableResult.js

@@ -15,4 +15,3 @@ export default class ParseTableResult {
         this.CurrentLine = 0;
     }
 }
-//# sourceMappingURL=ParseTableResult.js.map

package/lib/plugins/gridtables/index.d.ts

@@ -1,2 +1 @@
 export default function gridTableRulePlugin(md: any): void;
-//# sourceMappingURL=index.d.ts.map

package/lib/plugins/gridtables/index.js

@@ -2,10 +2,9 @@
  *  Copyright (c) Bas Verweij. All rights reserved.
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import gridTableRule from "./rules/gridtable";
+import gridTableRule from './rules/gridtable';
 export default function gridTableRulePlugin(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 md) {
-    md.block.ruler.before("table", "gridtable", gridTableRule(md));
+    md.block.ruler.before('table', 'gridtable', gridTableRule(md));
 }
-//# sourceMappingURL=index.js.map

package/lib/plugins/gridtables/interfaces/markdown-it/IState.d.ts

@@ -1,4 +1,4 @@
-import IToken from "./IToken";
+import IToken from './IToken';
 export default interface IState {
     src: string;
     bMarks: number[];
@@ -8,4 +8,3 @@ export default interface IState {
     line: number;
     push(action: string, tag: string, level: number): IToken;
 }
-//# sourceMappingURL=IState.d.ts.map

package/lib/plugins/gridtables/interfaces/markdown-it/IState.js

@@ -3,4 +3,3 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 export {};
-//# sourceMappingURL=IState.js.map

package/lib/plugins/gridtables/interfaces/markdown-it/IToken.d.ts

@@ -4,4 +4,3 @@ export default interface IToken {
     map: number[];
     attrSet(name: string, value: string): void;
 }
-//# sourceMappingURL=IToken.d.ts.map

package/lib/plugins/gridtables/interfaces/markdown-it/IToken.js

@@ -3,4 +3,3 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 export {};
-//# sourceMappingURL=IToken.js.map

package/lib/plugins/gridtables/interfaces/markdown-it/TRuleFunction.d.ts

@@ -1,4 +1,3 @@
-import IState from "./IState";
+import IState from './IState';
 type TRuleFunction = (state: IState, startLine: number, endLine: number, silent: boolean) => boolean;
 export default TRuleFunction;
-//# sourceMappingURL=TRuleFunction.d.ts.map

package/lib/plugins/gridtables/interfaces/markdown-it/TRuleFunction.js

@@ -3,4 +3,3 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 export {};
-//# sourceMappingURL=TRuleFunction.js.map

package/lib/plugins/gridtables/rules/gridtable.d.ts

@@ -1,4 +1,3 @@
-import * as MarkdownIt from "markdown-it";
-import TRuleFunction from "../interfaces/markdown-it/TRuleFunction";
+import * as MarkdownIt from 'markdown-it';
+import TRuleFunction from '../interfaces/markdown-it/TRuleFunction';
 export default function gridTableRule(md: MarkdownIt): TRuleFunction;
-//# sourceMappingURL=gridtable.d.ts.map

package/lib/plugins/gridtables/rules/gridtable.js

@@ -2,16 +2,16 @@
  *  Copyright (c) Bas Verweij. All rights reserved.
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import emitTable from "../common/markdown-it/EmitTable";
-import getCharCodeAtStartOfLine from "../common/markdown-it/GetCharCodeAtStartOfLine";
-import parseTable from "../common/markdown-it/ParseTable";
+import emitTable from '../common/markdown-it/EmitTable';
+import getCharCodeAtStartOfLine from '../common/markdown-it/GetCharCodeAtStartOfLine';
+import parseTable from '../common/markdown-it/ParseTable';
 export default function gridTableRule(md) {
     return function (state, startLine, endLine, silent) {
-        if (getCharCodeAtStartOfLine(state, startLine) !== 0x2B) {
+        if (getCharCodeAtStartOfLine(state, startLine) !== 0x2b) {
             // line does not start with a '+'
             return false;
         }
-        let parseResult = parseTable(state, startLine, endLine);
+        const parseResult = parseTable(state, startLine, endLine);
         if (!parseResult.Success) {
             return false;
         }
@@ -23,4 +23,3 @@ export default function gridTableRule(md) {
         return true;
     };
 }
-//# sourceMappingURL=gridtable.js.map

package/lib/plugins/index.d.ts

@@ -0,0 +1,15 @@
+import gridTableRulePlugin from './gridtables';
+export { gridTableRulePlugin };
+import mermaidPlugin from './mermaid';
+export { mermaidPlugin };
+export * from './callouts';
+export * from './cites';
+export * from './decorator';
+export * from './divs';
+export * from './figure-divs';
+export * from './figures';
+export * from './math';
+export * from './shortcodes';
+export * from './spans';
+export * from './table-captions';
+export * from './yaml';

package/lib/plugins/index.js

@@ -0,0 +1,21 @@
+/*
+ * index.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import gridTableRulePlugin from './gridtables';
+export { gridTableRulePlugin };
+import mermaidPlugin from './mermaid';
+export { mermaidPlugin };
+export * from './callouts';
+export * from './cites';
+export * from './decorator';
+export * from './divs';
+export * from './figure-divs';
+export * from './figures';
+export * from './math';
+export * from './shortcodes';
+export * from './spans';
+export * from './table-captions';
+export * from './yaml';

package/lib/plugins/math.d.ts

@@ -1,5 +1,6 @@
-import type MarkdownIt from "markdown-it";
+import type MarkdownIt from 'markdown-it';
 export declare const kTokMathBlock = "math_block";
 export declare const kTokMathInline = "math_inline";
-export declare function mathjaxPlugin(md: MarkdownIt): void;
-//# sourceMappingURL=math.d.ts.map
+export declare function mathjaxPlugin(md: MarkdownIt, options?: {
+    enableInlines?: boolean;
+}): void;

package/lib/plugins/math.js

@@ -4,8 +4,8 @@
  * Copyright (C) 2020-2023 Posit Software, PBC
  *
  */
-export const kTokMathBlock = "math_block";
-export const kTokMathInline = "math_inline";
+export const kTokMathBlock = 'math_block';
+export const kTokMathInline = 'math_inline';
 function renderMath(content, convertOptions) {
     if (convertOptions.display) {
         return `<div class='quarto-display-math'>\\[${content}\\]</div>`;
@@ -33,17 +33,17 @@ function isValidDelim(state, pos) {
     }
     return {
         can_open: can_open,
-        can_close: can_close,
+        can_close: can_close
     };
 }
 function math_inline(state, silent) {
-    if (state.src[state.pos] !== "$") {
+    if (state.src[state.pos] !== '$') {
         return false;
     }
     let res = isValidDelim(state, state.pos);
     if (!res.can_open) {
         if (!silent) {
-            state.pending += "$";
+            state.pending += '$';
         }
         state.pos += 1;
         return true;
@@ -54,15 +54,15 @@ function math_inline(state, silent) {
     // we have found an opening delimieter already.
     const start = state.pos + 1;
     let match = start;
-    while ((match = state.src.indexOf("$", match)) !== -1) {
+    while ((match = state.src.indexOf('$', match)) !== -1) {
         // Found potential $, look for escapes, pos will point to
         // first non escape when complete
         let pos = match - 1;
-        while (state.src[pos] === "\\") {
+        while (state.src[pos] === '\\') {
             pos -= 1;
         }
         // Even number of escapes, potential closing delimiter found
-        if ((match - pos) % 2 == 1) {
+        if ((match - pos) % 2 === 1) {
             break;
         }
         match += 1;
@@ -70,7 +70,7 @@ function math_inline(state, silent) {
     // No closing delimter found.  Consume $ and continue.
     if (match === -1) {
         if (!silent) {
-            state.pending += "$";
+            state.pending += '$';
         }
         state.pos = start;
         return true;
@@ -78,7 +78,7 @@ function math_inline(state, silent) {
     // Check if we have empty content, ie: $$.  Do not parse.
     if (match - start === 0) {
         if (!silent) {
-            state.pending += "$$";
+            state.pending += '$$';
         }
         state.pos = start + 1;
         return true;
@@ -87,14 +87,14 @@ function math_inline(state, silent) {
     res = isValidDelim(state, match);
     if (!res.can_close) {
         if (!silent) {
-            state.pending += "$";
+            state.pending += '$';
         }
         state.pos = start;
         return true;
     }
     if (!silent) {
-        const token = state.push("math_inline", "math", 0);
-        token.markup = "$";
+        const token = state.push('math_inline', 'math', 0);
+        token.markup = '$';
         token.content = state.src.slice(start, match);
     }
     state.pos = match + 1;
@@ -102,11 +102,11 @@ function math_inline(state, silent) {
 }
 function math_block(state, start, end, silent) {
     let next, lastPos;
-    let found = false, pos = state.bMarks[start] + state.tShift[start], max = state.eMarks[start], lastLine = "";
+    let found = false, pos = state.bMarks[start] + state.tShift[start], max = state.eMarks[start], lastLine = '';
     if (pos + 2 > max) {
         return false;
     }
-    if (state.src.slice(pos, pos + 2) !== "$$") {
+    if (state.src.slice(pos, pos + 2) !== '$$') {
         return false;
     }
     pos += 2;
@@ -114,7 +114,7 @@ function math_block(state, start, end, silent) {
     if (silent) {
         return true;
     }
-    if (firstLine.trim().slice(-2) === "$$") {
+    if (firstLine.trim().slice(-2) === '$$') {
         // Single line expression
         firstLine = firstLine.trim().slice(0, -2);
         found = true;
@@ -134,44 +134,46 @@ function math_block(state, start, end, silent) {
         const line = state.src.slice(pos, max).trim();
         const match = line.match(/^\$\$\s*(\{.*\})?\s*$/);
         if (match) {
-            lastPos = state.src.slice(0, max).lastIndexOf("$$");
+            lastPos = state.src.slice(0, max).lastIndexOf('$$');
             lastLine = state.src.slice(pos, lastPos);
             attrStr = match[1];
             found = true;
         }
     }
     state.line = next + 1;
-    const token = state.push(kTokMathBlock, "math", 0);
+    const token = state.push(kTokMathBlock, 'math', 0);
     token.block = true;
     if (attrStr) {
         token.info = attrStr;
     }
     token.content =
-        (firstLine && firstLine.trim() ? firstLine + "\n" : "") +
+        (firstLine && firstLine.trim() ? firstLine + '\n' : '') +
             state.getLines(start + 1, next, state.tShift[start], true) +
-            (lastLine && lastLine.trim() ? lastLine : "");
+            (lastLine && lastLine.trim() ? lastLine : '');
     token.map = [start, state.line];
-    token.markup = "$$";
+    token.markup = '$$';
     return true;
 }
-export function mathjaxPlugin(md) {
+export function mathjaxPlugin(md, options) {
     // Default options
+    options = options || {};
+    const enableInlines = options.enableInlines !== undefined ? options.enableInlines : true;
     const convertOptions = {
         display: false
     };
     // set MathJax as the renderer for markdown-it-simplemath
-    md.inline.ruler.after("escape", kTokMathInline, math_inline);
-    md.block.ruler.after("blockquote", kTokMathBlock, math_block, {
-        alt: ["paragraph", "reference", "blockquote", "list"],
+    md.inline.ruler.after('escape', kTokMathInline, math_inline);
+    md.block.ruler.after('blockquote', kTokMathBlock, math_block, {
+        alt: ['paragraph', 'reference', 'blockquote', 'list']
     });
-    md.renderer.rules.math_inline = function (tokens, idx) {
-        convertOptions.display = false;
-        return renderMath(tokens[idx].content, convertOptions);
-    };
+    if (enableInlines) {
+        md.renderer.rules.math_inline = function (tokens, idx) {
+            convertOptions.display = false;
+            return renderMath(tokens[idx].content, convertOptions);
+        };
+    }
     md.renderer.rules.math_block = function (tokens, idx) {
         convertOptions.display = true;
         return renderMath(tokens[idx].content, convertOptions);
     };
 }
-;
-//# sourceMappingURL=math.js.map

package/lib/plugins/mermaid/index.d.ts

@@ -1,5 +1,4 @@
-import MarkdownIt from "markdown-it";
+import MarkdownIt from 'markdown-it';
 export default function mermaidPlugin(md: MarkdownIt, options: {
     dark?: boolean;
 }): void;
-//# sourceMappingURL=index.d.ts.map

package/lib/plugins/mermaid/index.js

@@ -1,21 +1,24 @@
-import Mermaid from "mermaid";
+import Mermaid from 'mermaid';
 export default function mermaidPlugin(md, options) {
-    const kLang = "mermaid";
-    const kContainer = "quarto-mermaid";
+    const kLang = 'mermaid';
+    const kContainer = 'quarto-mermaid';
     Mermaid.initialize({
-        securityLevel: "loose",
-        theme: options.dark ? "dark" : "default",
-        ...options,
+        securityLevel: 'loose',
+        theme: options.dark ? 'dark' : 'default',
+        ...options
     });
     const defaultFenceRenderer = md.renderer.rules.fence;
     // Render custom code types as SVGs, letting the fence parser do all the heavy lifting.
     function mermaidFenceRenderer(tokens, idx, options, env, slf) {
         const token = tokens[idx];
-        if (token.info === kLang || (token.attrs !== null && token.attrs.length === 1 && token.attrs[0][0] === kLang)) {
-            let imageHTML = "";
+        if (token.info === kLang ||
+            (token.attrs !== null &&
+                token.attrs.length === 1 &&
+                token.attrs[0][0] === kLang)) {
+            let imageHTML = '';
             const imageAttrs = [];
             // Create element to render into
-            const element = document.createElement("div");
+            const element = document.createElement('div');
             document.body.appendChild(element);
             // Render with Mermaid
             try {
@@ -24,8 +27,8 @@ export default function mermaidPlugin(md, options) {
                     const mermaidEl = document.getElementById(kContainer);
                     if (mermaidEl !== null) {
                         imageAttrs.push([
-                            "style",
-                            `max-width:${mermaidEl.style.maxWidth};max-height:${mermaidEl.style.maxHeight}`,
+                            'style',
+                            `max-width:${mermaidEl.style.maxWidth};max-height:${mermaidEl.style.maxHeight}`
                         ]);
                     }
                     // Store HTML
@@ -39,7 +42,10 @@ export default function mermaidPlugin(md, options) {
                 element.remove();
             }
             // Store encoded image data
-            imageAttrs.push(["src", `data:image/svg+xml,${encodeURIComponent(imageHTML)}`]);
+            imageAttrs.push([
+                'src',
+                `data:image/svg+xml,${encodeURIComponent(imageHTML)}`
+            ]);
             return `<img ${slf.renderAttrs({ attrs: imageAttrs })}>`;
         }
         else {
@@ -47,9 +53,8 @@ export default function mermaidPlugin(md, options) {
                 return defaultFenceRenderer(tokens, idx, options, env, slf);
             }
             // Missing fence renderer!
-            return "";
+            return '';
         }
     }
     md.renderer.rules.fence = mermaidFenceRenderer;
 }
-//# sourceMappingURL=index.js.map