@quarto/jupyterlab-quarto 0.1.44 → 0.2.3

package/lib/plugins/callouts.js

@@ -0,0 +1,210 @@
+import Token from 'markdown-it/lib/token';
+import { addClass, readAttrValue } from './utils/markdownit';
+import { kTokDivClose, kTokDivOpen } from './divs';
+const kTokCalloutOpen = 'quarto_callout_open';
+const kTokCalloutClose = 'quarto_callout_close';
+const kTokCalloutTitleOpen = 'quarto_callout_title_open';
+const kTokCalloutTitleClose = 'quarto_callout_title_close';
+const kTokCalloutContentOpen = 'quarto_callout_content_open';
+const kTokCalloutContentClose = 'quarto_callout_content_close';
+const kCalloutPrefix = 'callout-';
+const kCalloutRuleName = 'quarto-callouts';
+export const calloutPlugin = (md) => {
+    // Handle pandoc-style divs
+    md.core.ruler.push(kCalloutRuleName, state => {
+        const noteStartCallout = (callout, depth) => {
+            if (calloutDepth === -1) {
+                calloutDepth = depth;
+            }
+            state.env['quarto-active-callout'] = callout;
+        };
+        const noteCloseCallout = () => {
+            calloutDepth = -1;
+            state.env['quarto-active-callout'] = undefined;
+        };
+        const activeCallout = () => {
+            return state.env['quarto-active-callout'];
+        };
+        const isCloseCallout = (depth) => {
+            return calloutDepth === depth;
+        };
+        const titleOpenTok = (title) => {
+            const token = new Token(kTokCalloutTitleOpen, '', 1);
+            token.tag = 'div';
+            token.attrs = [['class', 'callout-header']];
+            if (title) {
+                token.attrs.push(['title', title]);
+            }
+            return token;
+        };
+        const titleCloseTok = () => {
+            const token = new Token(kTokCalloutTitleClose, '', -1);
+            token.tag = 'div';
+            return token;
+        };
+        const contentOpenTok = () => {
+            const token = new Token(kTokCalloutContentOpen, '', 1);
+            token.tag = 'div';
+            token.attrs = [['class', 'callout-body-container callout-body']];
+            return token;
+        };
+        const contentCloseTok = () => {
+            const token = new Token(kTokCalloutContentClose, '', -1);
+            token.tag = 'div';
+            return token;
+        };
+        const outTokens = [];
+        let calloutDepth = -1;
+        let divDepth = 0;
+        // just started callout - process title
+        // finished processing title - process content
+        let calloutState = 'scanning';
+        for (const token of state.tokens) {
+            switch (calloutState) {
+                case 'add-title':
+                    if (token.type === 'heading_open') {
+                        outTokens.push(titleOpenTok());
+                        calloutState = 'capturing-title';
+                    }
+                    else {
+                        const callout = activeCallout();
+                        outTokens.push(titleOpenTok(callout.title));
+                        outTokens.push(titleCloseTok());
+                        calloutState = 'add-body';
+                    }
+                    break;
+                case 'capturing-title':
+                    if (token.type === 'heading_close') {
+                        outTokens.push(titleCloseTok());
+                        calloutState = 'add-body';
+                    }
+                    else {
+                        outTokens.push(token);
+                    }
+                    break;
+                case 'add-body':
+                    outTokens.push(contentOpenTok());
+                    outTokens.push(token);
+                    calloutState = 'capturing-body';
+                    break;
+                case 'scanning':
+                default:
+                    if (token.type === kTokDivOpen) {
+                        divDepth++;
+                        const callout = parseCallout(token.attrs);
+                        if (callout) {
+                            noteStartCallout(callout, divDepth);
+                            calloutState = 'add-title';
+                            const openCallout = new Token(kTokCalloutOpen, '', 1);
+                            openCallout.attrs = openCallout.attrs || [];
+                            openCallout.meta = callout;
+                            outTokens.push(openCallout);
+                        }
+                        else {
+                            outTokens.push(token);
+                        }
+                    }
+                    else if (token.type === kTokDivClose) {
+                        if (isCloseCallout(divDepth)) {
+                            outTokens.push(contentCloseTok());
+                            outTokens.push(new Token(kTokCalloutClose, '', -1));
+                            noteCloseCallout();
+                        }
+                        else {
+                            outTokens.push(token);
+                        }
+                        divDepth--;
+                    }
+                    else {
+                        outTokens.push(token);
+                    }
+                    break;
+            }
+        }
+        state.tokens = outTokens;
+        return false;
+    });
+    md.renderer.rules[kTokCalloutOpen] = renderStartCallout;
+    md.renderer.rules[kTokCalloutClose] = renderEndCallout;
+    md.renderer.rules[kTokCalloutTitleOpen] = renderStartCalloutTitle;
+    md.renderer.rules[kTokCalloutTitleClose] = renderEndCalloutTitle;
+};
+// Render pandoc-style divs
+function renderStartCallout(tokens, idx, _options, _env, self) {
+    const token = tokens[idx];
+    const callout = token.meta;
+    // Add classes decorating as callout
+    token.attrs = addClass(`callout ${callout.clz}`, token.attrs);
+    // Add class that reflects the style
+    token.attrs = addClass(appearanceClass(callout.appearance), token.attrs);
+    return `<div ${self.renderAttrs(token)}>`;
+}
+// Render pandoc-style divs
+function renderEndCallout() {
+    return '</div>';
+}
+function renderStartCalloutTitle(tokens, idx) {
+    const token = tokens[idx];
+    const title = readAttrValue('title', token.attrs) || '';
+    const startContent = `
+<div class="callout-header">
+<div class="callout-icon-container">
+  <i class="callout-icon"></i>
+</div>
+<div class="callout-title-container">${title}
+`;
+    return startContent;
+}
+function renderEndCalloutTitle() {
+    return '</div>\n</div>';
+}
+const calloutAppearance = (val) => {
+    if (val) {
+        switch (val) {
+            case 'minimal':
+                return 'minimal';
+            case 'simple':
+                return 'simple';
+            case 'default':
+            default:
+                return 'default';
+        }
+    }
+    else {
+        return 'default';
+    }
+};
+const parseCallout = (attrs) => {
+    if (attrs === null) {
+        return undefined;
+    }
+    const classAttr = attrs.find(attr => {
+        return attr[0] === 'class';
+    });
+    if (!classAttr) {
+        return undefined;
+    }
+    const classes = classAttr[1].split(' ');
+    const calloutClass = classes.find(clz => {
+        return clz.startsWith('callout-');
+    });
+    if (calloutClass) {
+        const type = calloutClass.replace(kCalloutPrefix, '');
+        const title = readAttrValue('title', attrs) ||
+            type.slice(0, 1).toUpperCase() + type.slice(1);
+        const appearance = calloutAppearance(readAttrValue('appearance', attrs));
+        return {
+            type: type || 'note',
+            clz: calloutClass,
+            title,
+            appearance
+        };
+    }
+    else {
+        return undefined;
+    }
+};
+const appearanceClass = (appearance) => {
+    const style = appearance || 'default';
+    return `callout-style-${style}`;
+};

package/lib/plugins/cites.d.ts

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

package/lib/plugins/cites.js

@@ -0,0 +1,166 @@
+/*
+ * citation.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+const kTokCite = 'quarto_cite';
+export const citationPlugin = (md) => {
+    // Very simple plugin example that surrounds @text with `code`
+    md.core.ruler.push('quarto-citation', state => {
+        const tokens = state.tokens;
+        for (const token of tokens) {
+            if (token.type === 'inline' && token.children) {
+                // Rebuild the child list
+                const children = [];
+                for (let i = 0; i < token.children.length; i++) {
+                    const child = token.children[i];
+                    if (child.type === 'text') {
+                        const content = child.content;
+                        const textToken = (text) => {
+                            const newToken = new state.Token('text', '', 0);
+                            newToken.content = text.join('');
+                            return newToken;
+                        };
+                        let text = [];
+                        const flushText = () => {
+                            if (text.length) {
+                                children.push(textToken(text));
+                                text = [];
+                            }
+                        };
+                        let cite = [];
+                        const flushCite = () => {
+                            var _a;
+                            if (cite.length) {
+                                // Determine the cite style
+                                let style = cite[0] === '-' ? 'suppress-author' : 'in-text';
+                                if (bracketCount > 0) {
+                                    style = 'normal';
+                                }
+                                // The classes
+                                const clz = ['cite', style];
+                                // If the cite ends in punctuation, trim that off and make that text
+                                const puncText = [];
+                                // Trim off ending punctuation
+                                if ([
+                                    ':',
+                                    '.',
+                                    '#',
+                                    '$',
+                                    '%',
+                                    '&',
+                                    '-',
+                                    '+',
+                                    '?',
+                                    '<',
+                                    '>',
+                                    '~',
+                                    '/',
+                                    '!'
+                                ].includes(cite[cite.length - 1])) {
+                                    puncText.push(cite[cite.length - 1]);
+                                    cite = cite.slice(0, -1);
+                                }
+                                // Make a cite token
+                                const newToken = new state.Token(kTokCite, '', 0);
+                                newToken.content = cite.join('');
+                                newToken.attrs = newToken.attrs || [];
+                                (_a = newToken.attrs) === null || _a === void 0 ? void 0 : _a.push(['class', clz.join(' ')]);
+                                children.push(newToken);
+                                cite = [];
+                                if (puncText.length > 0) {
+                                    children.push(textToken(puncText));
+                                }
+                            }
+                        };
+                        let capture = 'text';
+                        let bracketCount = 0;
+                        for (let j = 0; j < content.length; j++) {
+                            const char = content.charAt(j);
+                            if (char === '@') {
+                                if ((text.length === 1 && text[0] === '-') ||
+                                    (text.length > 1 &&
+                                        text[text.length - 1] === '-' &&
+                                        text[text.length - 2] === '[')) {
+                                    cite.push('-');
+                                    cite.push(char);
+                                    text.pop();
+                                    flushText();
+                                    capture = 'cite';
+                                }
+                                else if (text[text.length - 1] === ' ') {
+                                    flushText();
+                                    cite.push(char);
+                                    capture = 'cite';
+                                }
+                                else if (text[text.length - 1] === '-' &&
+                                    text[text.length - 2] === ' ') {
+                                    text = text.slice(0, -1);
+                                    flushText();
+                                    cite.push('-');
+                                    cite.push(char);
+                                    capture = 'cite';
+                                }
+                                else if (text[text.length - 1] === '[' &&
+                                    text[text.length - 2] === ' ') {
+                                    flushText();
+                                    cite.push(char);
+                                    capture = 'cite';
+                                }
+                                else if (text.length === 0) {
+                                    cite.push(char);
+                                    capture = 'cite';
+                                }
+                                else {
+                                    if (capture === 'cite') {
+                                        cite.push(char);
+                                    }
+                                    else {
+                                        text.push(char);
+                                    }
+                                }
+                            }
+                            else if (char === ' ') {
+                                capture = 'text';
+                                flushCite();
+                                text.push(char);
+                            }
+                            else if (char === '[') {
+                                bracketCount++;
+                                text.push(char);
+                            }
+                            else if (char === ']') {
+                                bracketCount--;
+                                capture = 'text';
+                                flushCite();
+                                text.push(char);
+                            }
+                            else {
+                                if (capture === 'cite') {
+                                    cite.push(char);
+                                }
+                                else {
+                                    text.push(char);
+                                }
+                            }
+                        }
+                        flushCite();
+                        flushText();
+                    }
+                    else {
+                        children.push(child);
+                    }
+                }
+                token.children = children.length > 0 ? children : null;
+            }
+        }
+    });
+    md.renderer.rules[kTokCite] = renderCite;
+};
+// Render pandoc-style divs
+function renderCite(tokens, idx, _options, _env, self) {
+    const token = tokens[idx];
+    const citeContent = `<code ${self.renderAttrs(token)}>${token.content}</code>`;
+    return citeContent;
+}

package/lib/plugins/decorator.d.ts

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

package/lib/plugins/decorator.js

@@ -0,0 +1,58 @@
+import Token from 'markdown-it/lib/token';
+import { attributeDecorator, decorator } from './utils/html';
+import { kTokDivOpen } from './divs';
+import { kTokFigureOpen } from './figures';
+import { kTokHeadingOpen, kTokTableOpen } from './utils/tok';
+import { kTokMathBlock } from './math';
+const kTokDecorator = 'quarto_decorator';
+const kQuartoDecoratorOptions = 'quarto-decorator-options';
+export const decoratorPlugin = (md) => {
+    md.core.ruler.push('quarto-decorator', state => {
+        const outTokens = [];
+        for (const token of state.tokens) {
+            if (token.type === 'fence' && !token.attrs && token.info) {
+                outTokens.push(decoratorTokForToken(token));
+            }
+            else if (token.type === kTokHeadingOpen && token.attrs) {
+                outTokens.push(decoratorTokForToken(token));
+            }
+            else if (token.type === kTokDivOpen && token.attrs) {
+                outTokens.push(decoratorTokForToken(token));
+            }
+            else if (token.type === kTokFigureOpen && token.attrs) {
+                outTokens.push(decoratorTokForToken(token, { hide: { attributes: true } }));
+            }
+            else if (token.type === kTokTableOpen && token.attrs) {
+                outTokens.push(decoratorTokForToken(token));
+            }
+            else if (token.type === kTokMathBlock && token.attrs) {
+                outTokens.push(decoratorTokForToken(token));
+            }
+            outTokens.push(token);
+        }
+        state.tokens = outTokens;
+    });
+    md.renderer.rules[kTokDecorator] = renderDecorator;
+};
+function decoratorTokForToken(token, options) {
+    const decoratorTok = new Token(kTokDecorator, 'div', 1);
+    decoratorTok.attrs = token.attrs;
+    decoratorTok.info = token.info;
+    if (options) {
+        decoratorTok.meta = decoratorTok.meta || {};
+        decoratorTok.meta[kQuartoDecoratorOptions] = options;
+    }
+    return decoratorTok;
+}
+// Render pandoc-style divs
+function renderDecorator(tokens, idx) {
+    var _a;
+    const token = tokens[idx];
+    const decoratorOptions = (_a = token.meta) === null || _a === void 0 ? void 0 : _a[kQuartoDecoratorOptions];
+    if (token.info) {
+        return decorator([token.info]);
+    }
+    else {
+        return attributeDecorator(token, decoratorOptions);
+    }
+}

package/lib/plugins/divs.d.ts

@@ -0,0 +1,5 @@
+import type MarkdownIt from 'markdown-it/lib';
+export declare const kDivRuleName = "pandocDiv";
+export declare const kTokDivOpen = "pandoc_div_open";
+export declare const kTokDivClose = "pandoc_div_close";
+export declare const divPlugin: (md: MarkdownIt) => void;

package/lib/plugins/divs.js

@@ -0,0 +1,111 @@
+import { addClass } from './utils/markdownit';
+export const kDivRuleName = 'pandocDiv';
+export const kTokDivOpen = 'pandoc_div_open';
+export const kTokDivClose = 'pandoc_div_close';
+export const divPlugin = (md) => {
+    // Render pandoc-style divs
+    function renderStartDiv(tokens, idx, _options, _env, self) {
+        // Add a class to designate that this is a quarto dev
+        const token = tokens[idx];
+        token.attrs = addClass('quarto-div', token.attrs);
+        return `<div ${self.renderAttrs(token)}>`;
+    }
+    // Render pandoc-style divs
+    function renderEndDiv() {
+        return '</div>';
+    }
+    // TODO Implement a better test during validation run
+    // Handle pandoc-style divs
+    md.block.ruler.before('fence', kDivRuleName, (state, start, _end, silent) => {
+        // This is a validation run, can ignore
+        if (silent) {
+            return true;
+        }
+        // Get the line for parsing
+        const lineStart = state.bMarks[start] + state.tShift[start];
+        const lineEnd = state.eMarks[start];
+        const line = state.src.slice(lineStart, lineEnd);
+        // The current state of the divs (e.g. is there an open)
+        // div. Data structure holds key that is the number of colons
+        const divState = state.env.quartoOpenDivs || {};
+        const incrementDivCount = (fence) => {
+            var _a;
+            state.env.quartoDivLevel = ((_a = state.env.quartoDivLevel) !== null && _a !== void 0 ? _a : 0) + 1;
+            state.env.quartoOpenDivs = state.env.quartoOpenDivs || {};
+            const current = state.env.quartoOpenDivs[fence] || 0;
+            state.env.quartoOpenDivs[fence] = Math.max(0, current + 1);
+        };
+        const decrementDivCount = (fence) => {
+            state.env.quartoDivLevel--;
+            state.env.quartoOpenDivs = state.env.quartoOpenDivs || {};
+            const current = state.env.quartoOpenDivs[fence] || 0;
+            state.env.quartoOpenDivs[fence] = Math.max(0, current - 1);
+        };
+        // Three or more colons followed by a an optional brace with attributes
+        const divBraceRegex = /^(:::+)\s*(?:(\{[\s\S]+?\}))?$/;
+        // Three or more colons followed by a string with no braces
+        const divNoBraceRegex = /^(:::+)\s*(?:([^{}\s]+?))?$/;
+        const matchers = [divBraceRegex, divNoBraceRegex];
+        let match;
+        for (const matcher of matchers) {
+            match = matcher.exec(line);
+            if (match) {
+                break;
+            }
+        }
+        if (match) {
+            // There is a div here, is one already open?
+            const divFence = match[1];
+            const attr = match[2];
+            // Is this open?
+            let isOpenDiv = false;
+            const openCount = divState[divFence];
+            if (!openCount || openCount === 0) {
+                // There isn't an existing open div at this level (number of colons)
+                isOpenDiv = true;
+            }
+            else if (attr) {
+                // If it has attributes it is always open
+                isOpenDiv = true;
+            }
+            if (isOpenDiv) {
+                // Add to the open count (or set it to 1)
+                incrementDivCount(divFence);
+                // Make an open token
+                const token = state.push(kTokDivOpen, 'div', 1);
+                token.markup = line;
+                // Allow this to be parsed for attributes by markdown-it-attr
+                if (attr && attr.startsWith('{')) {
+                    token.info = attr;
+                }
+                else if (attr) {
+                    token.info = `{.${attr}}`;
+                }
+                token.block = true;
+                token.meta = {
+                    line: state.line,
+                    level: state.env.quartoDivLevel
+                };
+            }
+            else {
+                // Subtract from the open count (min zero)
+                const level = state.env.quartoDivLevel;
+                decrementDivCount(divFence);
+                // Make a close token
+                const token = state.push(kTokDivClose, 'div', -1);
+                token.markup = line;
+                token.meta = {
+                    line: state.line,
+                    level
+                };
+            }
+            state.line = start + 1;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, { alt: [] });
+    md.renderer.rules[kTokDivOpen] = renderStartDiv;
+    md.renderer.rules[kTokDivClose] = renderEndDiv;
+};

package/lib/plugins/figure-divs.d.ts

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

package/lib/plugins/figure-divs.js

@@ -0,0 +1,54 @@
+/*
+ * figure-divs.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { readAttrValue } from './utils/markdownit';
+import { kTokInline, kTokParaClose, kTokParaOpen } from './utils/tok';
+import { kTokDivClose, kTokDivOpen } from './divs';
+import { kTokFigCaptionClose, kTokFigCaptionOpen, mutateToFigureTok } from './figures';
+const kFigureDivRuleName = 'quarto-figure-divs';
+const kFigurePrefix = 'fig-';
+export const figureDivsPlugin = (md) => {
+    // Handle pandoc-style divs
+    md.core.ruler.push(kFigureDivRuleName, state => {
+        const isFigureDiv = [];
+        for (let i = 0; i < state.tokens.length; i++) {
+            const token = state.tokens[i];
+            if (token.type === kTokDivOpen) {
+                const id = readAttrValue('id', token.attrs);
+                if (id === null || id === void 0 ? void 0 : id.startsWith(kFigurePrefix)) {
+                    isFigureDiv.push(true);
+                    mutateToFigureTok(token, 'open');
+                }
+                else {
+                    // Note the div, but not a figure div
+                    isFigureDiv.push(false);
+                }
+            }
+            else if (token.type === kTokDivClose) {
+                const isFigDiv = isFigureDiv.pop();
+                if (isFigDiv) {
+                    // If the preview token is paragraph, use that as the caption
+                    if (i - 3 >= 0) {
+                        const maybeParaStart = state.tokens[i - 3];
+                        const maybeInline = state.tokens[i - 2];
+                        const maybeParaEnd = state.tokens[i - 1];
+                        if (maybeParaStart.type === kTokParaOpen &&
+                            maybeParaEnd.type === kTokParaClose &&
+                            maybeInline.type === kTokInline) {
+                            mutateToFigCaption(state.tokens[i - 3], 'open');
+                            mutateToFigCaption(state.tokens[i - 1], 'close');
+                        }
+                    }
+                    mutateToFigureTok(token, 'close');
+                }
+            }
+        }
+    });
+};
+const mutateToFigCaption = (token, type) => {
+    token.tag = 'figcaption';
+    token.type = type === 'open' ? kTokFigCaptionClose : kTokFigCaptionOpen;
+};

package/lib/plugins/figures.d.ts

@@ -0,0 +1,16 @@
+import MarkdownIt from 'markdown-it';
+import Token from 'markdown-it/lib/token';
+export interface FigureOptions {
+    dataType?: boolean;
+    link?: boolean;
+    figcaption?: boolean;
+    copyAttrs?: boolean;
+    tabindex?: boolean;
+    lazyLoading?: boolean;
+}
+export declare const kTokFigureOpen = "figure_open";
+export declare const kTokFigureClose = "figure_close";
+export declare const kTokFigCaptionOpen = "figcaption_open";
+export declare const kTokFigCaptionClose = "figcaption_close";
+export declare const mutateToFigureTok: (token: Token, type: 'open' | 'close') => void;
+export declare function figuresPlugin(md: MarkdownIt, options: FigureOptions): void;