@quarto/jupyterlab-quarto 0.1.44 → 0.2.3

package/lib/plugins/math.js

@@ -0,0 +1,179 @@
+/*
+ * math.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+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>`;
+    }
+    else {
+        return `<span class='quarto-inline-math'>\\(${content}\\)</span>`;
+    }
+}
+// Test if potential opening or closing delimieter
+// Assumes that there is a "$" at state.src[pos]
+function isValidDelim(state, pos) {
+    const max = state.posMax;
+    let can_open = true;
+    let can_close = true;
+    const prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1, nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
+    // Check non-whitespace conditions for opening and closing, and
+    // check that closing delimeter isn't followed by a number
+    if (prevChar === 0x20 /* " " */ ||
+        prevChar === 0x09 /* \t */ ||
+        (nextChar >= 0x30 /* "0" */ && nextChar <= 0x39) /* "9" */) {
+        can_close = false;
+    }
+    if (nextChar === 0x20 /* " " */ || nextChar === 0x09 /* \t */) {
+        can_open = false;
+    }
+    return {
+        can_open: can_open,
+        can_close: can_close
+    };
+}
+function math_inline(state, silent) {
+    if (state.src[state.pos] !== '$') {
+        return false;
+    }
+    let res = isValidDelim(state, state.pos);
+    if (!res.can_open) {
+        if (!silent) {
+            state.pending += '$';
+        }
+        state.pos += 1;
+        return true;
+    }
+    // First check for and bypass all properly escaped delimieters
+    // This loop will assume that the first leading backtick can not
+    // be the first character in state.src, which is known since
+    // we have found an opening delimieter already.
+    const start = state.pos + 1;
+    let match = start;
+    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] === '\\') {
+            pos -= 1;
+        }
+        // Even number of escapes, potential closing delimiter found
+        if ((match - pos) % 2 === 1) {
+            break;
+        }
+        match += 1;
+    }
+    // No closing delimter found.  Consume $ and continue.
+    if (match === -1) {
+        if (!silent) {
+            state.pending += '$';
+        }
+        state.pos = start;
+        return true;
+    }
+    // Check if we have empty content, ie: $$.  Do not parse.
+    if (match - start === 0) {
+        if (!silent) {
+            state.pending += '$$';
+        }
+        state.pos = start + 1;
+        return true;
+    }
+    // Check for valid closing delimiter
+    res = isValidDelim(state, match);
+    if (!res.can_close) {
+        if (!silent) {
+            state.pending += '$';
+        }
+        state.pos = start;
+        return true;
+    }
+    if (!silent) {
+        const token = state.push('math_inline', 'math', 0);
+        token.markup = '$';
+        token.content = state.src.slice(start, match);
+    }
+    state.pos = match + 1;
+    return true;
+}
+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 = '';
+    if (pos + 2 > max) {
+        return false;
+    }
+    if (state.src.slice(pos, pos + 2) !== '$$') {
+        return false;
+    }
+    pos += 2;
+    let firstLine = state.src.slice(pos, max);
+    if (silent) {
+        return true;
+    }
+    if (firstLine.trim().slice(-2) === '$$') {
+        // Single line expression
+        firstLine = firstLine.trim().slice(0, -2);
+        found = true;
+    }
+    let attrStr = undefined;
+    for (next = start; !found;) {
+        next++;
+        if (next >= end) {
+            break;
+        }
+        pos = state.bMarks[next] + state.tShift[next];
+        max = state.eMarks[next];
+        if (pos < max && state.tShift[next] < state.blkIndent) {
+            // non-empty line with negative indent should stop the list:
+            break;
+        }
+        const line = state.src.slice(pos, max).trim();
+        const match = line.match(/^\$\$\s*(\{.*\})?\s*$/);
+        if (match) {
+            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);
+    token.block = true;
+    if (attrStr) {
+        token.info = attrStr;
+    }
+    token.content =
+        (firstLine && firstLine.trim() ? firstLine + '\n' : '') +
+            state.getLines(start + 1, next, state.tShift[start], true) +
+            (lastLine && lastLine.trim() ? lastLine : '');
+    token.map = [start, state.line];
+    token.markup = '$$';
+    return true;
+}
+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']
+    });
+    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);
+    };
+}

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

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+export default function mermaidPlugin(md: MarkdownIt, options: {
+    dark?: boolean;
+}): void;

package/lib/plugins/mermaid/index.js

@@ -0,0 +1,60 @@
+import Mermaid from 'mermaid';
+export default function mermaidPlugin(md, options) {
+    const kLang = 'mermaid';
+    const kContainer = 'quarto-mermaid';
+    Mermaid.initialize({
+        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 = '';
+            const imageAttrs = [];
+            // Create element to render into
+            const element = document.createElement('div');
+            document.body.appendChild(element);
+            // Render with Mermaid
+            try {
+                Mermaid.mermaidAPI.render(kContainer, token.content, (html) => {
+                    // We need to forcibly extract the max-width/height attributes to set on img tag
+                    const mermaidEl = document.getElementById(kContainer);
+                    if (mermaidEl !== null) {
+                        imageAttrs.push([
+                            'style',
+                            `max-width:${mermaidEl.style.maxWidth};max-height:${mermaidEl.style.maxHeight}`
+                        ]);
+                    }
+                    // Store HTML
+                    imageHTML = html;
+                }, element);
+            }
+            catch (e) {
+                return `<pre>Failed to render mermaid diagram.${e}</pre>`;
+            }
+            finally {
+                element.remove();
+            }
+            // Store encoded image data
+            imageAttrs.push([
+                'src',
+                `data:image/svg+xml,${encodeURIComponent(imageHTML)}`
+            ]);
+            return `<img ${slf.renderAttrs({ attrs: imageAttrs })}>`;
+        }
+        else {
+            if (defaultFenceRenderer !== undefined) {
+                return defaultFenceRenderer(tokens, idx, options, env, slf);
+            }
+            // Missing fence renderer!
+            return '';
+        }
+    }
+    md.renderer.rules.fence = mermaidFenceRenderer;
+}

package/lib/plugins/shortcodes.d.ts

@@ -0,0 +1,3 @@
+import type MarkdownIt from 'markdown-it/lib';
+export declare const kShortcode = "shortcode";
+export declare const shortcodePlugin: (md: MarkdownIt) => void;

package/lib/plugins/shortcodes.js

@@ -0,0 +1,32 @@
+import { escapeHtml } from 'markdown-it/lib/common/utils';
+export const kShortcode = 'shortcode';
+export const shortcodePlugin = (md) => {
+    const shortcode = (state, silent) => {
+        // {{< shortcode >}}
+        if (state.src.slice(state.pos, state.pos + 3) !== '{{<') {
+            return false;
+        }
+        const shortcodeEndRegex = />}}/g;
+        // ignore if shortcode doesn't end
+        const end = state.src.slice(state.pos).search(shortcodeEndRegex);
+        if (end === -1) {
+            return false;
+        }
+        const shortcodeContent = state.src.slice(state.pos + 3, state.pos + end);
+        if (!silent) {
+            const token = state.push('shortcode', 'shortcode', 0);
+            token.markup = '';
+            token.content = shortcodeContent;
+        }
+        state.pos += end + 3;
+        return true;
+    };
+    md.inline.ruler.after('escape', kShortcode, shortcode);
+    const renderShortcode = (tokens, idx) => {
+        const token = tokens[idx];
+        const content = token.content;
+        // insert shortcode braces and escape content's html entities
+        return `<span class="shortcode">${escapeHtml(`{{<${content}>}}`)}</span>`;
+    };
+    md.renderer.rules[kShortcode] = renderShortcode;
+};

package/lib/plugins/spans.d.ts

@@ -0,0 +1,2 @@
+import MarkdownIt from 'markdown-it';
+export declare function spansPlugin(md: MarkdownIt): void;

package/lib/plugins/spans.js

@@ -0,0 +1,37 @@
+/*
+ * span.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+export function spansPlugin(md) {
+    function span(state) {
+        const max = state.posMax;
+        if (state.src.charCodeAt(state.pos) !== 0x5b) {
+            // opening [
+            return false;
+        }
+        const labelStart = state.pos + 1;
+        const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
+        if (labelEnd < 0) {
+            // parser failed to find closing ]
+            return false;
+        }
+        const pos = labelEnd + 1;
+        if (pos < max && state.src.charCodeAt(pos) === 0x7b /* { */) {
+            // probably found span
+            state.pos = labelStart;
+            state.posMax = labelEnd;
+            state.push('span_open', 'span', 1);
+            state.md.inline.tokenize(state);
+            state.push('span_close', 'span', -1);
+            state.pos = pos;
+            state.posMax = max;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    md.inline.ruler.push('quarto-spans', span);
+}

package/lib/plugins/table-captions.d.ts

@@ -0,0 +1,2 @@
+import MarkdownIt from 'markdown-it';
+export declare const tableCaptionPlugin: (md: MarkdownIt) => void;

package/lib/plugins/table-captions.js

@@ -0,0 +1,72 @@
+/*
+ * table-captions.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { kTokInline, kTokParaClose, kTokParaOpen, kTokTableClose, kTokTableOpen, kTokText } from './utils/tok';
+const kTableCaptionRule = 'quarto-table-captions';
+export const tableCaptionPlugin = (md) => {
+    md.core.ruler.push(kTableCaptionRule, state => {
+        const tableIdxs = [];
+        const tablePoss = [];
+        // Identify tables that we'd like to process
+        // The tables must be the bottom first (we will process them bottom to
+        // top to ensure that the positions remain accurate as the tokens
+        // are mutated
+        for (let i = 0; i < state.tokens.length; i++) {
+            const token = state.tokens[i];
+            if (token.type === kTokTableOpen) {
+                tableIdxs.push(i);
+            }
+            else if (token.type === kTokTableClose) {
+                const start = tableIdxs.pop();
+                if (start) {
+                    tablePoss.unshift({
+                        start,
+                        end: i
+                    });
+                }
+            }
+        }
+        // Look just past the tables and if there is a paragraph that is
+        // a table caption, extract that and place it in the table
+        for (const tablePos of tablePoss) {
+            resolveTableCaption(state.tokens, tablePos.start, tablePos.end);
+        }
+    });
+};
+function resolveTableCaption(tokens, tblStartPos, tblEndPos) {
+    // Must have at least three tokens past the table end
+    if (tokens.length > tblEndPos + 3) {
+        if (tokens[tblEndPos + 1].type === kTokParaOpen &&
+            tokens[tblEndPos + 2].type === kTokInline &&
+            tokens[tblEndPos + 3].type === kTokParaClose) {
+            const maybeCaption = tokens[tblEndPos + 2];
+            const isText = maybeCaption.children !== null &&
+                maybeCaption.children.length > 0 &&
+                maybeCaption.children[0].type === kTokText;
+            const maybeCaptionText = isText && maybeCaption.children ? maybeCaption.children[0].content : '';
+            const match = maybeCaptionText.match(/^:\s([^{}]*)(?:\{.*\}){0,1}$/);
+            if (match && match[1]) {
+                // Carve out the existing tokens
+                const capTokens = tokens.splice(tblEndPos + 1, 3);
+                // We have the caption, remove the paragraph and return
+                // the caption
+                capTokens[0].type = 'table_caption';
+                capTokens[0].tag = 'caption';
+                // Forward any attributes from the caption up to the table
+                tokens[tblStartPos].attrs = capTokens[0].attrs;
+                capTokens[0].attrs = [];
+                // Trim the content
+                if (capTokens[1].children && capTokens[1].children.length > 0) {
+                    capTokens[1].children[0].content = match[1];
+                }
+                // Close the caption
+                capTokens[2].type = 'table_caption';
+                capTokens[2].tag = 'caption';
+                tokens.splice(tblStartPos + 1, 0, ...capTokens);
+            }
+        }
+    }
+}

package/lib/plugins/utils/html.d.ts

@@ -0,0 +1,11 @@
+import Token from 'markdown-it/lib/token';
+export interface DecoratorOptions {
+    customClass?: string;
+    hide: {
+        id?: boolean;
+        classes?: boolean;
+        attributes?: boolean;
+    };
+}
+export declare const decorator: (contents: string[], customClass?: string) => string;
+export declare const attributeDecorator: (token: Token, options?: DecoratorOptions) => string;

package/lib/plugins/utils/html.js

@@ -0,0 +1,50 @@
+/*
+ * html.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { readAttrValue } from './markdownit';
+export const decorator = (contents, customClass) => {
+    if (contents.length > 0) {
+        // Provide a decorator with the attributes
+        return `<div class="quarto-attribute-decorator${customClass ? ' ' + customClass : ''}">${contents.map(decoratorSpan).join('')}</div>`;
+    }
+    else {
+        // There is no decorator - no attributes
+        return '';
+    }
+};
+export const attributeDecorator = (token, options) => {
+    var _a;
+    // id
+    const id = readAttrValue('id', token.attrs);
+    // classes
+    const clz = readAttrValue('class', token.attrs);
+    // other attributes
+    const otherAttrs = (_a = token.attrs) === null || _a === void 0 ? void 0 : _a.filter(attr => {
+        return attr[0] !== 'id' && attr[0] !== 'class';
+    });
+    // Create a decorator for the div
+    const contents = [];
+    if (id && !(options === null || options === void 0 ? void 0 : options.hide.id)) {
+        contents.push(`#${id}`);
+    }
+    if (clz && !(options === null || options === void 0 ? void 0 : options.hide.classes)) {
+        const clzStr = clz
+            .split(' ')
+            .map(cls => `.${cls}`)
+            .join(' ');
+        contents.push(clzStr);
+    }
+    if (otherAttrs && otherAttrs.length > 0 && !(options === null || options === void 0 ? void 0 : options.hide.attributes)) {
+        const otherAttrStr = otherAttrs === null || otherAttrs === void 0 ? void 0 : otherAttrs.map(attr => {
+            return `${attr[0]}="${attr[1]}"`;
+        }).join(' ');
+        contents.push(otherAttrStr);
+    }
+    return decorator(contents, options === null || options === void 0 ? void 0 : options.customClass);
+};
+const decoratorSpan = (contents) => {
+    return `<span class="quarto-attribute-decorator-content">${contents}</span>`;
+};

package/lib/plugins/utils/markdownit.d.ts

@@ -0,0 +1,15 @@
+export declare const hasClass: (clz: string, attrs: null | [
+    string,
+    string
+][]) => boolean | undefined;
+export declare const readAttrValue: (name: string, attrs: null | [
+    string,
+    string
+][]) => string | undefined;
+export declare const addClass: (clz: string, attrs: null | [
+    string,
+    string
+][]) => [
+    string,
+    string
+][];

package/lib/plugins/utils/markdownit.js

@@ -0,0 +1,46 @@
+/*
+ * markdownit.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+export const hasClass = (clz, attrs) => {
+    if (attrs === null) {
+        return false;
+    }
+    const classes = readAttrValue('class', attrs);
+    if (classes === null) {
+        return false;
+    }
+    else {
+        return classes === null || classes === void 0 ? void 0 : classes.split(' ').includes(clz);
+    }
+};
+export const readAttrValue = (name, attrs) => {
+    if (attrs === null) {
+        return undefined;
+    }
+    const attr = attrs.find(attr => {
+        return attr[0] === name;
+    });
+    return attr ? attr[1] : undefined;
+};
+export const addClass = (clz, attrs) => {
+    if (attrs === null) {
+        attrs = [];
+        attrs.push(['class', clz]);
+        return attrs;
+    }
+    else {
+        const clzIdx = attrs.findIndex(attr => attr[0] === 'class');
+        if (clzIdx >= 0) {
+            const currentClz = attrs[clzIdx];
+            attrs[clzIdx] = ['class', `${currentClz[1]} ${clz}`.trim()];
+            return attrs;
+        }
+        else {
+            attrs.push(['class', clz]);
+            return attrs;
+        }
+    }
+};

package/lib/plugins/utils/tok.d.ts

@@ -0,0 +1,7 @@
+export declare const kTokParaOpen = "paragraph_open";
+export declare const kTokParaClose = "paragraph_close";
+export declare const kTokInline = "inline";
+export declare const kTokTableOpen = "table_open";
+export declare const kTokTableClose = "table_close";
+export declare const kTokText = "text";
+export declare const kTokHeadingOpen = "heading_open";

package/lib/plugins/utils/tok.js

@@ -0,0 +1,13 @@
+/*
+ * tok.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+export const kTokParaOpen = 'paragraph_open';
+export const kTokParaClose = 'paragraph_close';
+export const kTokInline = 'inline';
+export const kTokTableOpen = 'table_open';
+export const kTokTableClose = 'table_close';
+export const kTokText = 'text';
+export const kTokHeadingOpen = 'heading_open';

package/lib/plugins/yaml.d.ts

@@ -0,0 +1,2 @@
+import MarkdownIt from 'markdown-it';
+export declare function yamlPlugin(md: MarkdownIt, cb?: (yaml: unknown) => void): void;