@quarto/jupyterlab-quarto 0.1.44 → 0.2.3

package/lib/plugins/yaml.js

@@ -0,0 +1,330 @@
+/*
+ * markdownit-yaml.ts
+ *
+ * Copyright (C) 2022 by Posit Software, PBC
+ * Copyright (c) 2016-2020 ParkSB.
+ *
+ * Unless you have received this program directly from Posit Software pursuant
+ * to the terms of a commercial license agreement with Posit Software, then
+ * this program is licensed to you under the terms of version 3 of the
+ * GNU Affero General Public License. This program is distributed WITHOUT
+ * ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
+ * AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.
+ *
+ */
+import * as yaml from 'js-yaml';
+import { decorator } from './utils/html';
+// Typescript version of https://github.com/parksb/markdown-it-front-matter
+// TODO: Rationalize this with quarto-core/src/markdownit-yaml.ts
+//       This is a copy with rendering added - the core tokenizing function is identical (or should be)
+const kTokFrontMatter = 'front_matter';
+export function yamlPlugin(md, cb) {
+    const min_markers = 3, marker_str = '-', marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length;
+    function frontMatter(state, startLine, endLine, silent) {
+        let pos, nextLine, start_content, user_closed = false, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
+        // Check out the first character of the first line quickly,
+        // this should filter out non-front matter
+        if (startLine !== 0 || marker_char !== state.src.charCodeAt(0)) {
+            return false;
+        }
+        // Check out the rest of the marker string
+        // while pos <= 3
+        for (pos = start + 1; pos <= max; pos++) {
+            if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
+                start_content = pos + 1;
+                break;
+            }
+        }
+        const marker_count = Math.floor((pos - start) / marker_len);
+        if (marker_count < min_markers) {
+            return false;
+        }
+        pos -= (pos - start) % marker_len;
+        // Since start is found, we can report success here in validation mode
+        if (silent) {
+            return true;
+        }
+        // Search for the end of the block
+        nextLine = startLine;
+        for (;;) {
+            nextLine++;
+            if (nextLine >= endLine) {
+                // unclosed block should be autoclosed by end of document.
+                // also block seems to be autoclosed by end of parent
+                break;
+            }
+            if (state.src.slice(start, max) === '...') {
+                break;
+            }
+            start = state.bMarks[nextLine] + state.tShift[nextLine];
+            max = state.eMarks[nextLine];
+            if (start < max && state.sCount[nextLine] < state.blkIndent) {
+                // non-empty line with negative indent should stop the list:
+                // - ```
+                //  test
+                break;
+            }
+            if (marker_char !== state.src.charCodeAt(start)) {
+                continue;
+            }
+            if (state.sCount[nextLine] - state.blkIndent >= 4) {
+                // closing fence should be indented less than 4 spaces
+                continue;
+            }
+            for (pos = start + 1; pos <= max; pos++) {
+                if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
+                    break;
+                }
+            }
+            // closing code fence must be at least as long as the opening one
+            if (Math.floor((pos - start) / marker_len) < marker_count) {
+                continue;
+            }
+            // make sure tail has spaces only
+            pos -= (pos - start) % marker_len;
+            pos = state.skipSpaces(pos);
+            if (pos < max) {
+                continue;
+            }
+            // found!
+            user_closed = true;
+            break;
+        }
+        // Ensure that we have real yaml here
+        const markup = state.src.slice(startLine, pos);
+        const yaml = parseFrontMatterStr(markup);
+        const isYamlBlock = yaml !== null && typeof yaml === 'object';
+        // If this is yaml, render it
+        if (isYamlBlock && user_closed) {
+            const old_parent = state.parentType;
+            const old_line_max = state.lineMax;
+            const token = state.push(kTokFrontMatter, '', 0);
+            token.hidden = true;
+            token.markup = markup;
+            token.block = true;
+            token.map = [startLine, pos];
+            token.meta = state.src.slice(start_content, start - 1);
+            if (cb) {
+                cb(token.meta);
+            }
+            state.parentType = old_parent;
+            state.lineMax = old_line_max;
+            state.line = nextLine + (user_closed ? 1 : 0);
+            return true;
+        }
+        else {
+            // This is not yaml, just continue
+            state.line = nextLine + 1;
+            return false;
+        }
+    }
+    md.block.ruler.before('table', kTokFrontMatter, frontMatter, {
+        alt: ['paragraph', 'reference', 'blockquote', 'list']
+    });
+    // Add rendering
+    md.renderer.rules[kTokFrontMatter] = renderFrontMatter;
+}
+function renderFrontMatter(tokens, idx) {
+    const token = tokens[idx];
+    // Parse the markup
+    const frontUnknown = parseFrontMatterStr(token.markup);
+    // Extract important content
+    if (typeof frontUnknown === 'object') {
+        const titleBlock = {};
+        const frontMatter = frontUnknown;
+        const readStr = (key) => {
+            if (frontMatter[key] === undefined) {
+                return undefined;
+            }
+            else if (typeof frontMatter[key] === 'string') {
+                const val = frontMatter[key];
+                delete frontMatter[key];
+                return val;
+            }
+            else {
+                return undefined;
+            }
+        };
+        // Read simple values
+        titleBlock.title = readStr('title');
+        titleBlock.subtitle = readStr('subtitle');
+        titleBlock.abstract = readStr('abstract');
+        titleBlock.date = readStr('date');
+        titleBlock.modified = readStr('date-modified');
+        titleBlock.doi = readStr('doi');
+        // Read Authors
+        titleBlock.authors = parseAuthor(frontMatter.author || frontMatter.authors);
+        delete frontMatter.author;
+        delete frontMatter.authors;
+        // The final rendered HTML output
+        const titleLines = [];
+        // Render the title block and other yaml options
+        const titleRendered = renderTitle(titleBlock);
+        titleLines.push(titleRendered);
+        if (Object.keys(frontMatter).length > 0) {
+            // decorator
+            const decor = decorator(['Options']);
+            titleLines.push(decor);
+            // yaml
+            const yamlDump = yaml.dump(frontMatter);
+            const otherYamlRendered = `<pre class="quarto-frontmatter-container"><code class="cm-s-jupyter language-yaml quarto-frontmatter">${yamlDump}</code></pre>`;
+            titleLines.push(otherYamlRendered);
+        }
+        return titleLines.join('\n');
+    }
+    else {
+        return '';
+    }
+}
+// TODO: Use core function instead
+function parseFrontMatterStr(str) {
+    str = str.replace(/---\s*$/, '');
+    try {
+        return yaml.load(str, { schema: yaml.FAILSAFE_SCHEMA });
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+function renderTitle(titleBlock) {
+    var _a;
+    const rendered = [];
+    if (titleBlock.title) {
+        rendered.push(`<h1>${titleBlock.title}</h1>`);
+    }
+    if (titleBlock.subtitle) {
+        rendered.push(`<p class="quarto-subtitle">${titleBlock.subtitle}</p>`);
+    }
+    const metadataBlocks = [];
+    if (titleBlock.authors && ((_a = titleBlock.authors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        const names = [];
+        const affils = [];
+        for (let i = 0; i < titleBlock.authors.length; i++) {
+            const author = titleBlock.authors[i];
+            if (author.orcid) {
+                names.push({
+                    value: `${author.name}<a href="https://orcid.org/${author.orcid}" class="quarto-orcid"><i></i></a>`,
+                    padded: i > 0
+                });
+            }
+            else {
+                names.push({ value: author.name, padded: i > 0 });
+            }
+            // Place empty rows to allow affiliations to line up
+            const emptyCount = author.affil
+                ? Math.max(author.affil.length - 1, 0)
+                : 0;
+            for (let j = 0; j < emptyCount; j++) {
+                names.push({ value: '&nbsp;' });
+            }
+            // Collect affilations
+            if (author.affil) {
+                for (let k = 0; k < author.affil.length; k++) {
+                    const affil = author.affil[k];
+                    affils.push({
+                        value: affil,
+                        padded: i > 0 && k === 0
+                    });
+                }
+            }
+        }
+        const authLabel = names.length === 1 ? 'Author' : 'Authors';
+        metadataBlocks.push(renderDocMeta(authLabel, names));
+        if (affils.length > 0) {
+            const affilLabel = affils.length === 1 ? 'Affiliation' : 'Affiliations';
+            metadataBlocks.push(renderDocMeta(affilLabel, affils));
+        }
+    }
+    if (titleBlock.date) {
+        metadataBlocks.push(renderDocMeta('Date', [{ value: titleBlock.date }]));
+    }
+    if (titleBlock.modified) {
+        metadataBlocks.push(renderDocMeta('Modified', [{ value: titleBlock.modified }]));
+    }
+    if (titleBlock.doi) {
+        metadataBlocks.push(renderDocMeta('DOI', [
+            {
+                value: `<a href="https://doi.org/${titleBlock.doi}">${titleBlock.doi}</a>`
+            }
+        ]));
+    }
+    if (metadataBlocks.length > 0) {
+        rendered.push(renderDocMetas(metadataBlocks));
+    }
+    if (titleBlock.abstract) {
+        rendered.push(`<p class="quarto-abstract">${titleBlock.abstract}</p>`);
+    }
+    return rendered.join('\n');
+}
+function renderDocMetas(docMetas) {
+    const rendered = [];
+    rendered.push('<div class="quarto-meta-block">');
+    docMetas.forEach(docMeta => {
+        rendered.push(docMeta);
+    });
+    rendered.push('</div>');
+    return rendered.join('\n');
+}
+function renderDocMeta(label, vals) {
+    const rendered = [];
+    rendered.push('<div class="quarto-meta">');
+    rendered.push(`<p class="quarto-meta-title">${label}</p>`);
+    vals.forEach(val => {
+        const clz = val.padded ? ' class="quarto-meta-padded"' : '';
+        rendered.push(`<p${clz}>${val.value}</p>`);
+    });
+    rendered.push('</div>');
+    return rendered.join('\n');
+}
+function parseAuthor(author) {
+    var _a;
+    const authorsRaw = Array.isArray(author) ? author : [author];
+    const authors = [];
+    for (const authorRaw of authorsRaw) {
+        if (typeof authorRaw === 'string') {
+            authors.push({
+                name: authorRaw
+            });
+        }
+        else if (typeof authorRaw === 'object') {
+            const str = (key, defaultValue) => {
+                if (typeof authorRaw[key] === 'string') {
+                    return authorRaw[key];
+                }
+                else {
+                    return defaultValue;
+                }
+            };
+            const affiliations = [];
+            const affiliationSimple = str('affiliation');
+            if (affiliationSimple) {
+                affiliations.push(affiliationSimple);
+            }
+            else if (authorRaw.affiliations) {
+                const affils = Array.isArray(authorRaw.affiliations)
+                    ? authorRaw.affiliations
+                    : [authorRaw.affiliations];
+                affils.forEach((affilRaw) => {
+                    if (typeof affilRaw === 'string') {
+                        affiliations.push(affilRaw);
+                        // eslint-disable-next-line no-constant-condition
+                    }
+                    else if (typeof (affilRaw === 'object')) {
+                        const affilRecord = affilRaw;
+                        const name = affilRecord.name;
+                        if (typeof name === 'string') {
+                            affiliations.push(name);
+                        }
+                    }
+                });
+            }
+            authors.push({
+                name: (_a = str('name', '')) !== null && _a !== void 0 ? _a : '',
+                orcid: str('orcid'),
+                affil: affiliations
+            });
+        }
+    }
+    return authors;
+}

package/lib/providers/attrs.d.ts

@@ -0,0 +1 @@
+export declare const attrs: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/attrs.js

@@ -0,0 +1,15 @@
+/*
+ * attrs.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { markdownItExtension } from './provider';
+export const attrs = markdownItExtension({
+    id: '@quarto/attributes',
+    title: 'Markdown Attributes',
+    plugin: async () => {
+        const plugin = await import('markdown-it-attrs');
+        return [plugin.default];
+    }
+});

package/lib/providers/callouts.d.ts

@@ -0,0 +1 @@
+export declare const callouts: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/callouts.js

@@ -0,0 +1,15 @@
+/*
+ * callouts.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { calloutPlugin } from '../plugins/callouts';
+import { markdownItExtension } from './provider';
+export const callouts = markdownItExtension({
+    id: '@quarto/callouts',
+    title: 'Quarto callouts',
+    plugin: async () => {
+        return [calloutPlugin];
+    }
+});

package/lib/providers/cites.d.ts

@@ -0,0 +1 @@
+export declare const cites: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/cites.js

@@ -0,0 +1,15 @@
+/*
+ * cites.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { citationPlugin } from '../plugins/cites';
+import { markdownItExtension } from './provider';
+export const cites = markdownItExtension({
+    id: '@quarto/cites',
+    title: 'Citations',
+    plugin: async () => {
+        return [citationPlugin];
+    }
+});

package/lib/providers/decorator.d.ts

@@ -0,0 +1 @@
+export declare const decorator: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/decorator.js

@@ -0,0 +1,15 @@
+/*
+ * code.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { decoratorPlugin } from '../plugins/decorator';
+import { markdownItExtension } from './provider';
+export const decorator = markdownItExtension({
+    id: '@quarto/fence',
+    title: 'Fenced Code Blocks',
+    plugin: async () => {
+        return [decoratorPlugin];
+    }
+});

package/lib/providers/deflist.d.ts

@@ -0,0 +1 @@
+export declare const deflist: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/deflist.js

@@ -0,0 +1,15 @@
+/*
+ * deflist.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { markdownItExtension } from './provider';
+export const deflist = markdownItExtension({
+    id: '@quarto/deflist',
+    title: 'Definition Lists',
+    plugin: async () => {
+        const plugin = await import('markdown-it-deflist');
+        return [plugin.default];
+    }
+});

package/lib/providers/divs.d.ts

@@ -0,0 +1 @@
+export declare const divs: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/divs.js

@@ -0,0 +1,27 @@
+/*
+ * callouts.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { divPlugin } from '../plugins/divs';
+import { markdownItExtension } from './provider';
+export const divs = markdownItExtension({
+    id: '@quarto/divs',
+    title: 'Pandoc fenced divs',
+    plugin: async () => {
+        return [divPlugin];
+    },
+    hooks: {
+        preParse: {
+            run: (content) => {
+                // Detect close divs that are directly after text (e.g. not back to back whitespace)
+                // and add a whitespace. This will cause the close div to become a 'block'
+                // rather than appearing as the end of the paragraph block
+                const blockedDivs = content.replace(kCloseDivNoBlock, '$1\n\n$2');
+                return Promise.resolve(blockedDivs);
+            }
+        }
+    }
+});
+const kCloseDivNoBlock = /([^\s])\n(:::+(?:\{.*\})?)/gm;

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

@@ -0,0 +1 @@
+export declare const figureDivs: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/figure-divs.js

@@ -0,0 +1,15 @@
+/*
+ * figure-divs.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { figureDivsPlugin } from '../plugins/figure-divs';
+import { markdownItExtension } from './provider';
+export const figureDivs = markdownItExtension({
+    id: '@quarto/figureDivs',
+    title: 'Quarto Figure Divs',
+    plugin: async () => {
+        return [figureDivsPlugin];
+    }
+});

package/lib/providers/figures.d.ts

@@ -0,0 +1 @@
+export declare const figures: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/figures.js

@@ -0,0 +1,15 @@
+/*
+ * figures.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { figuresPlugin } from '../plugins/figures';
+import { markdownItExtension } from './provider';
+export const figures = markdownItExtension({
+    id: '@quarto/figures',
+    title: 'Quarto figures',
+    plugin: async () => {
+        return [figuresPlugin, { figcaption: true, copyAttrs: true }];
+    }
+});

package/lib/providers/footnotes.d.ts

@@ -0,0 +1 @@
+export declare const footnotes: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/footnotes.js

@@ -0,0 +1,15 @@
+/*
+ * footnotes.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { markdownItExtension } from './provider';
+export const footnotes = markdownItExtension({
+    id: '@quarto/footnotes',
+    title: 'Footnotes',
+    plugin: async () => {
+        const footnotePlugin = await import('markdown-it-footnote');
+        return [footnotePlugin.default];
+    }
+});

package/lib/providers/gridtables.d.ts

@@ -0,0 +1 @@
+export declare const gridtables: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/gridtables.js

@@ -0,0 +1,15 @@
+/*
+ * gridtables.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import gridTableRulePlugin from '../plugins/gridtables';
+import { markdownItExtension } from './provider';
+export const gridtables = markdownItExtension({
+    id: '@quarto/gridtables',
+    title: 'Grid Tables',
+    plugin: async () => {
+        return [gridTableRulePlugin];
+    }
+});

package/lib/providers/math.d.ts

@@ -0,0 +1 @@
+export declare const math: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/math.js

@@ -0,0 +1,104 @@
+/*
+ * math.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { mathjaxPlugin } from '../plugins/math';
+import { markdownItExtension } from './provider';
+export const math = markdownItExtension({
+    id: '@quarto/math',
+    title: 'LaTex Math',
+    plugin: async () => {
+        return [mathjaxPlugin];
+    },
+    hooks: {
+        postRender: {
+            run: (node) => {
+                // Inject mathjax
+                const mathjaxId = 'MathJax-script';
+                const mathJaxScript = document.getElementById(mathjaxId);
+                if (!mathJaxScript) {
+                    const configEl = document.createElement('script');
+                    configEl.innerText = `
+
+MathJax = {
+  svg: {
+    fontCache: 'global'
+  },
+  startup: {
+    typeset: false,
+    pageReady: () => {
+      MathJax.startup.promise.then(() => {
+
+        const typesetMath = (els) => {
+          MathJax.startup.promise = MathJax.startup.promise
+            .then(() => {
+              return MathJax.typesetPromise(els); }
+            )
+            .catch((err) => console.log('Typeset failed: ' + err.message));
+          return MathJax.startup.promise;
+        };
+        
+        const typesetCellObserver = new MutationObserver((mutationList, observer) => { 
+          const els = mutationList.map((list) => list.target);          
+          const typesetEls = [];
+          for (const el of els) {
+            const childMathEls = el.querySelectorAll('.quarto-inline-math, .quarto-display-math');
+            if (childMathEls && childMathEls.length > 0) {
+              typesetEls.push(...childMathEls);
+            }
+          }
+          typesetMath(typesetEls);
+        });        
+
+        const containerObserver = new MutationObserver((mutationList, observer) => { 
+          const nodes = [];
+          mutationList.forEach((record) => {
+            for (const node of record.addedNodes) {
+              nodes.push(node);
+            }
+          });
+
+          const markdownNodes = nodes.filter((node) => {
+            return node.class.contains("jp-MarkdownCell");
+          }).forEach((node) => {
+            typesetCellObserver.observe(node, { childList: true, subtree: true });
+          });
+          
+        });
+
+        const nbContainer = document.querySelector('.jp-Notebook');
+        if (nbContainer !== null) {
+          containerObserver.observe(nbContainer, { childList: true });
+        }
+
+        const mathEls = document.body.querySelectorAll('.quarto-inline-math, .quarto-display-math');
+        return typesetMath([...mathEls]).then(() => {
+          for (const mathEl of mathEls) {
+            typesetCellObserver.observe(mathEl.parentElement, { childList: true, subtree: true });
+          }    
+        });
+      });
+    },
+  }
+};`;
+                    document.head.appendChild(configEl);
+                    const polyFillEl = document.createElement('script');
+                    polyFillEl.setAttribute('src', 'https://polyfill.io/v3/polyfill.min.js?features=es6');
+                    document.head.appendChild(polyFillEl);
+                    const scriptEl = document.createElement('script');
+                    scriptEl.id = mathjaxId;
+                    scriptEl.setAttribute('src', 'https://cdn.jsdelivr.net/npm/mathjax@3.0.1/es5/tex-mml-chtml.js');
+                    document.head.appendChild(scriptEl);
+                }
+                return Promise.resolve();
+            }
+        }
+    }
+});
+/*
+<script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
+<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
+
+*/

package/lib/providers/mermaid.d.ts

@@ -0,0 +1 @@
+export declare const mermaid: import("@jupyterlab/application").JupyterFrontEndPlugin<void>;

package/lib/providers/mermaid.js

@@ -0,0 +1,17 @@
+/*
+ * mermaid.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import mermaidPlugin from '../plugins/mermaid';
+import { markdownItExtension } from './provider';
+export const mermaid = markdownItExtension({
+    id: '@quarto/mermaid',
+    title: 'Mermaid',
+    plugin: async () => {
+        // Figure out whether this is dark mode
+        const isDark = document.body.getAttribute('data-jp-theme-light') === 'false';
+        return [mermaidPlugin, { dark: isDark }];
+    }
+});

package/lib/providers/provider.d.ts

@@ -0,0 +1,3 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { MarkdownItPluginProvider } from '../types';
+export declare function markdownItExtension(provider: MarkdownItPluginProvider): JupyterFrontEndPlugin<void>;