@quarto/jupyterlab-quarto 0.1.44 → 0.2.3

package/lib/plugins/figures.js

@@ -0,0 +1,98 @@
+/*
+ * figures.ts
+ *
+ * Copyright (C) 2020-2023 Posit Software, PBC
+ *
+ */
+import { kTokParaClose, kTokParaOpen } from './utils/tok';
+export const kTokFigureOpen = 'figure_open';
+export const kTokFigureClose = 'figure_close';
+export const kTokFigCaptionOpen = 'figcaption_open';
+export const kTokFigCaptionClose = 'figcaption_close';
+export const mutateToFigureTok = (token, type) => {
+    token.type = type === 'open' ? kTokFigureOpen : kTokFigureClose;
+    token.tag = 'figure';
+};
+export function figuresPlugin(md, options) {
+    options = options || {};
+    md.core.ruler.before('linkify', 'implicit_figures', state => {
+        // reset tabIndex on md.render()
+        let tabIndex = 1;
+        // do not process first and last token
+        for (let i = 1, l = state.tokens.length; i < l - 1; ++i) {
+            const token = state.tokens[i];
+            if (token.type !== 'inline') {
+                continue;
+            }
+            // children: image alone, or link_open -> image -> link_close
+            if (!token.children ||
+                (token.children.length !== 1 && token.children.length !== 3)) {
+                continue;
+            }
+            // one child, should be img
+            if (token.children.length === 1 && token.children[0].type !== 'image') {
+                continue;
+            }
+            // three children, should be image enclosed in link
+            if (token.children.length === 3 &&
+                (token.children[0].type !== 'link_open' ||
+                    token.children[1].type !== 'image' ||
+                    token.children[2].type !== 'link_close')) {
+                continue;
+            }
+            // prev token is paragraph open
+            if (i !== 0 && state.tokens[i - 1].type !== kTokParaOpen) {
+                continue;
+            }
+            // next token is paragraph close
+            if (i !== l - 1 && state.tokens[i + 1].type !== kTokParaClose) {
+                continue;
+            }
+            // The image
+            const image = token.children.length === 1 ? token.children[0] : token.children[1];
+            // The image must have a caption to count as a figure
+            if (!image.children || image.children.length === 0) {
+                continue;
+            }
+            // We have inline token containing an image only.
+            // Previous token is paragraph open.
+            // Next token is paragraph close.
+            // Lets replace the paragraph tokens with figure tokens.
+            const figure = state.tokens[i - 1];
+            mutateToFigureTok(figure, 'open');
+            mutateToFigureTok(state.tokens[i + 1], 'close');
+            if (options.dataType === true) {
+                state.tokens[i - 1].attrPush(['data-type', 'image']);
+            }
+            if (options.link === true && token.children.length === 1) {
+                token.children.unshift(new state.Token('link_open', 'a', 1));
+                const src = image.attrGet('src');
+                if (src !== null) {
+                    token.children[0].attrPush(['href', src]);
+                }
+                token.children.push(new state.Token('link_close', 'a', -1));
+            }
+            if (options.figcaption === true) {
+                if (image.children && image.children.length) {
+                    token.children.push(new state.Token(kTokFigCaptionOpen, 'figcaption', 1));
+                    token.children.splice(token.children.length, 0, ...image.children);
+                    token.children.push(new state.Token(kTokFigCaptionClose, 'figcaption', -1));
+                    image.children.length = 0;
+                }
+            }
+            if (options.copyAttrs && image.attrs) {
+                const f = options.copyAttrs === true ? '' : options.copyAttrs;
+                figure.attrs = image.attrs.filter(([k]) => k.match(f));
+            }
+            if (options.tabindex === true) {
+                // add a tabindex property
+                // you could use this with css-tricks.com/expanding-images-html5
+                state.tokens[i - 1].attrPush(['tabindex', String(tabIndex)]);
+                tabIndex++;
+            }
+            if (options.lazyLoading === true) {
+                image.attrPush(['loading', 'lazy']);
+            }
+        }
+    });
+}

package/lib/plugins/gridtables/common/gridtables/GetCells.d.ts

@@ -0,0 +1,7 @@
+/**
+ * getCells parses the lines found for a certain row, and transforms these to
+ * the separate cell lines.
+ *
+ * @param lines The lines for the row.
+ */
+export default function getCells(lines: string[][]): string[][];

package/lib/plugins/gridtables/common/gridtables/GetCells.js

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * getCells parses the lines found for a certain row, and transforms these to
+ * the separate cell lines.
+ *
+ * @param lines The lines for the row.
+ */
+export default function getCells(lines) {
+    const cells = [];
+    for (let i = 0; i < lines[0].length; i++) {
+        let cell = [];
+        for (let j = 0; j < lines.length; j++) {
+            const s = trimEnd(lines[j][i]);
+            if (s.length === 0 && cell.length === 0) {
+                // skip leading empty lines
+                continue;
+            }
+            cell.push(s);
+        }
+        // remove trailing empty lines
+        let j = cell.length - 1;
+        for (; j >= 0; j--) {
+            if (cell[j].length > 0) {
+                break;
+            }
+        }
+        if (j < cell.length - 1) {
+            cell = cell.slice(0, j + 1);
+        }
+        cells.push(cell);
+    }
+    return cells;
+}
+function trimEnd(s) {
+    const trimmed = s.trim();
+    if (trimmed.length === 0) {
+        return '';
+    }
+    return s.slice(0, s.indexOf(trimmed) + trimmed.length);
+}

package/lib/plugins/gridtables/common/gridtables/GetColumnWidths.d.ts

@@ -0,0 +1,7 @@
+/**
+ * getColumnWidths parses the provided line and returns the associated column widths.
+ *
+ * @param line The separator line to parse for the column widths.
+ * @returns The column widths for the provided line, or an empty array if the line is invalid.
+ */
+export default function getColumnWidths(line: string): number[];

package/lib/plugins/gridtables/common/gridtables/GetColumnWidths.js

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * getColumnWidths parses the provided line and returns the associated column widths.
+ *
+ * @param line The separator line to parse for the column widths.
+ * @returns The column widths for the provided line, or an empty array if the line is invalid.
+ */
+export default function getColumnWidths(line) {
+    // try to parse as a row separator line
+    let columnMatch = line.substr(1).match(/[:-][-]+[:-]\+/g);
+    if (columnMatch === null) {
+        // try to parse as a header separator line
+        columnMatch = line.substr(1).match(/[:=][=]+[:=]\+/g);
+    }
+    if (columnMatch === null) {
+        return [];
+    }
+    return columnMatch.map(s => s.length);
+}

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

@@ -0,0 +1,7 @@
+declare enum ColumnAlignments {
+    None = "",
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}
+export default ColumnAlignments;

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

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var ColumnAlignments;
+(function (ColumnAlignments) {
+    ColumnAlignments["None"] = "";
+    ColumnAlignments["Left"] = "left";
+    ColumnAlignments["Center"] = "center";
+    ColumnAlignments["Right"] = "right";
+})(ColumnAlignments || (ColumnAlignments = {}));
+export default ColumnAlignments;

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

@@ -0,0 +1,4 @@
+import * as MarkdownIt from 'markdown-it';
+import IState from '../../interfaces/markdown-it/IState';
+import ParseTableResult from './ParseTableResult';
+export default function emitTable(md: MarkdownIt, state: IState, result: ParseTableResult): void;

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

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+export default function emitTable(md, state, result) {
+    let offsets = result.SeparatorLineOffsets;
+    let token = state.push('table_open', 'table', 1);
+    token.map = [offsets[0], offsets[offsets.length - 1]];
+    if (result.HeaderLines.length > 0) {
+        // emit table header
+        const token = state.push('thead_open', 'thead', 1);
+        token.map = [offsets[0], offsets[1]];
+        const cells = getCells(result.HeaderLines);
+        processRow(md, state, 'th', result.ColumnAlignments, offsets[0], offsets[1], cells);
+        state.push('thead_close', 'thead', -1);
+        offsets = offsets.slice(1);
+    }
+    // emit table body
+    token = state.push('tbody_open', 'tbody', 1);
+    token.map = [offsets[0], offsets[offsets.length - 1]];
+    for (let i = 0; i < result.RowLines.length; 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) {
+    const token = state.push('tr_open', 'tr', 1);
+    token.map = [lineBegin, lineEnd];
+    for (let i = 0; i < cells.length; i++) {
+        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]};`);
+        }
+        if (cells[i].length === 0) {
+            // empty cell
+        }
+        else if (cells[i].length === 1) {
+            // single line cell -> emit as inline markdown
+            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();
+            // 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) {
+                cell = cell.slice(3, cell.length - 4);
+            }
+            const token = state.push('html_block', '', 0);
+            token.content = cell;
+            token.children = [];
+        }
+        state.push(tag + '_close', tag, -1);
+    }
+    state.push('tr_close', 'tr', -1);
+}

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

@@ -0,0 +1,8 @@
+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).
+ *
+ * @param state The Markdown It state.
+ */
+export default function getCharCodeAtStartOfLine(state: IState, line: number): number;

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

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * 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).
+ *
+ * @param state The Markdown It state.
+ */
+export default function getCharCodeAtStartOfLine(state, line) {
+    const pos = state.bMarks[line] + state.tShift[line];
+    if (pos >= state.eMarks[line]) {
+        return -1;
+    }
+    return state.src.charCodeAt(pos);
+}

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

@@ -0,0 +1,2 @@
+import IState from '../../interfaces/markdown-it/IState';
+export default function getLine(state: IState, line: number): string;

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

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export default function getLine(state, line) {
+    const start = state.bMarks[line] + state.blkIndent;
+    const end = state.eMarks[line];
+    return state.src.substr(start, end - start);
+}

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

@@ -0,0 +1,3 @@
+import IState from '../../interfaces/markdown-it/IState';
+import ParseTableResult from './ParseTableResult';
+export default function parseTable(state: IState, startLine: number, endLine: number): ParseTableResult;

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

@@ -0,0 +1,152 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+export default function parseTable(state, startLine, endLine) {
+    const result = new ParseTableResult();
+    let rowLine = getLine(state, startLine);
+    if (rowLine.charAt(0) !== '+') {
+        // line does not start with a '+'
+        return result;
+    }
+    result.ColumnWidths = getColumnWidths(rowLine);
+    if (result.ColumnWidths.length === 0) {
+        // no columns found
+        return result;
+    }
+    // initialize column alignments
+    result.ColumnAlignments = result.ColumnWidths.map(() => ColumnAlignments.None);
+    if (rowLine.indexOf(':') >= 0) {
+        // column alignment specifiers present in first row line
+        result.HeaderLess = true;
+        // set column alignments
+        result.ColumnAlignments = getColumnAlignments(rowLine, result.ColumnWidths);
+        // remove alignment specifiers for further matching
+        rowLine = rowLine.replace(/[:]/g, '-');
+    }
+    // create header line matcher
+    const headerLineMatcher = new RegExp('^\\+' +
+        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]);
+    }
+    // create cell line matcher
+    const cellLineMatcher = new RegExp('^\\|' +
+        result.ColumnWidths.map(w => `([^|]{${Math.ceil((w - 1) / 2)},${w - 1}})\\|`).join('') +
+        '$');
+    // save first separator line offset
+    result.SeparatorLineOffsets.push(startLine);
+    // continue to scan until a complete table is found, or an invalid line is encountered
+    let currentRow = [];
+    let currentLine = startLine + 1;
+    for (; currentLine <= endLine; currentLine++) {
+        const line = getLine(state, currentLine);
+        if (line.charCodeAt(0) === 0x2b) {
+            // '+'
+            // separator line
+            if (currentRow.length === 0) {
+                // no row lines since last separator -> invalid table
+                return result;
+            }
+            // save separator line offset
+            result.SeparatorLineOffsets.push(currentLine);
+            if (line === rowLine) {
+                // new regular row
+                result.RowLines.push(currentRow);
+                if (result.HeaderLines.length === 0) {
+                    result.HeaderLess = true;
+                }
+            }
+            else if (!result.HeaderLess && line.match(headerLineMatcher)) {
+                // found header line
+                if (result.HeaderLines.length > 0 || result.RowLines.length > 0) {
+                    // header already found, or not the first row -> invalid table
+                    return result;
+                }
+                // header row
+                result.HeaderLines = currentRow;
+                if (line.indexOf(':') >= 0) {
+                    // set column alignments
+                    result.ColumnAlignments = getColumnAlignments(line, result.ColumnWidths);
+                }
+            }
+            else {
+                // not a header or regular row -> invalid table
+                return result;
+            }
+            // reset current row
+            currentRow = [];
+        }
+        else if (line.charCodeAt(0) === 0x7c) {
+            // '|'
+            // cell line
+            const matches = line.match(cellLineMatcher);
+            if (matches === null) {
+                // cell line does not match -> invalid table
+                return result;
+            }
+            const cells = validateColumnWidths(matches, result.ColumnWidths);
+            if (cells === null) {
+                // cell line does not match -> invalid table
+                return result;
+            }
+            // add the line to the current row
+            currentRow.push(cells);
+        }
+        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)) {
+                // found a complete table
+                break;
+            }
+            return result;
+        }
+    }
+    result.CurrentLine = currentLine;
+    result.Success = true;
+    return result;
+}
+function getColumnAlignments(line, columnWidths) {
+    const alignments = [];
+    let left = 1;
+    let right = -1;
+    for (let i = 0; i < columnWidths.length; i++) {
+        right += columnWidths[i];
+        let alignment = ColumnAlignments.None;
+        if (line.charAt(right) === ':') {
+            if (line.charAt(left) === ':') {
+                alignment = ColumnAlignments.Center;
+            }
+            else {
+                alignment = ColumnAlignments.Right;
+            }
+        }
+        else if (line.charAt(left) === ':') {
+            alignment = ColumnAlignments.Left;
+        }
+        alignments.push(alignment);
+        left += columnWidths[i];
+    }
+    return alignments;
+}
+function validateColumnWidths(matches, columnWidths) {
+    const cells = [];
+    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]) {
+            return null;
+        }
+        cells.push(cell);
+    }
+    return cells;
+}

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

@@ -0,0 +1,12 @@
+import ColumnAlignments from './ColumnAlignments';
+export default class ParseTableResult {
+    Success: boolean;
+    ColumnWidths: number[];
+    ColumnOffsets: number[];
+    ColumnAlignments: ColumnAlignments[];
+    HeaderLess: boolean;
+    HeaderLines: string[][];
+    RowLines: string[][][];
+    SeparatorLineOffsets: number[];
+    CurrentLine: number;
+}

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

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export default class ParseTableResult {
+    constructor() {
+        this.Success = false;
+        this.ColumnWidths = [];
+        this.ColumnOffsets = [];
+        this.ColumnAlignments = [];
+        this.HeaderLess = false;
+        this.HeaderLines = [];
+        this.RowLines = [];
+        this.SeparatorLineOffsets = [];
+        this.CurrentLine = 0;
+    }
+}

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

@@ -0,0 +1 @@
+export default function gridTableRulePlugin(md: any): void;

package/lib/plugins/gridtables/index.js

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+export default function gridTableRulePlugin(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+md) {
+    md.block.ruler.before('table', 'gridtable', gridTableRule(md));
+}

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

@@ -0,0 +1,10 @@
+import IToken from './IToken';
+export default interface IState {
+    src: string;
+    bMarks: number[];
+    eMarks: number[];
+    blkIndent: number;
+    tShift: number[];
+    line: number;
+    push(action: string, tag: string, level: number): IToken;
+}

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

@@ -0,0 +1,5 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export {};

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

@@ -0,0 +1,6 @@
+export default interface IToken {
+    children: IToken[];
+    content: string;
+    map: number[];
+    attrSet(name: string, value: string): void;
+}

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

@@ -0,0 +1,5 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export {};

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

@@ -0,0 +1,3 @@
+import IState from './IState';
+type TRuleFunction = (state: IState, startLine: number, endLine: number, silent: boolean) => boolean;
+export default TRuleFunction;

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

@@ -0,0 +1,5 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Bas Verweij. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export {};

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

@@ -0,0 +1,3 @@
+import * as MarkdownIt from 'markdown-it';
+import TRuleFunction from '../interfaces/markdown-it/TRuleFunction';
+export default function gridTableRule(md: MarkdownIt): TRuleFunction;

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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+export default function gridTableRule(md) {
+    return function (state, startLine, endLine, silent) {
+        if (getCharCodeAtStartOfLine(state, startLine) !== 0x2b) {
+            // line does not start with a '+'
+            return false;
+        }
+        const parseResult = parseTable(state, startLine, endLine);
+        if (!parseResult.Success) {
+            return false;
+        }
+        if (silent) {
+            return true;
+        }
+        emitTable(md, state, parseResult);
+        state.line = parseResult.CurrentLine;
+        return true;
+    };
+}

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

@@ -0,0 +1,6 @@
+import type MarkdownIt from 'markdown-it';
+export declare const kTokMathBlock = "math_block";
+export declare const kTokMathInline = "math_inline";
+export declare function mathjaxPlugin(md: MarkdownIt, options?: {
+    enableInlines?: boolean;
+}): void;