@rse/ase 0.0.41 → 0.0.43

package/plugin/node_modules/katex/contrib/auto-render/splitAtDelimiters.ts

@@ -1,99 +0,0 @@
-/* eslint no-constant-condition:0 */
-
-export interface DelimiterSpec {
-    left: string;
-    right: string;
-    display: boolean;
-}
-
-export interface SplitAtDelimiterData {
-    type: "text" | "math";
-    data: string;
-    rawData?: string;
-    display?: boolean;
-}
-
-const findEndOfMath = function(delimiter: string, text: string, startIndex: number): number {
-    // Adapted from
-    // https://github.com/Khan/perseus/blob/master/src/perseus-markdown.jsx
-    let index = startIndex;
-    let braceLevel = 0;
-
-    const delimLength = delimiter.length;
-
-    while (index < text.length) {
-        const character = text[index];
-
-        if (braceLevel <= 0 &&
-            text.slice(index, index + delimLength) === delimiter) {
-            return index;
-        } else if (character === "\\") {
-            index++;
-        } else if (character === "{") {
-            braceLevel++;
-        } else if (character === "}") {
-            braceLevel--;
-        }
-
-        index++;
-    }
-
-    return -1;
-};
-
-const escapeRegex = function(string: string): string {
-    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-};
-
-const amsRegex = /^\\begin{/;
-
-const splitAtDelimiters = function(text: string, delimiters: DelimiterSpec[]): SplitAtDelimiterData[] {
-    let index;
-    const data: SplitAtDelimiterData[] = [];
-
-    const regexLeft = new RegExp(
-        "(" + delimiters.map((x) => escapeRegex(x.left)).join("|") + ")"
-    );
-
-    while (true) {
-        index = text.search(regexLeft);
-        if (index === -1) {
-            break;
-        }
-        if (index > 0) {
-            data.push({
-                type: "text",
-                data: text.slice(0, index),
-            });
-            text = text.slice(index); // now text starts with delimiter
-        }
-        // ... so this always succeeds:
-        const i = delimiters.findIndex((delim) => text.startsWith(delim.left));
-        index = findEndOfMath(delimiters[i].right, text, delimiters[i].left.length);
-        if (index === -1) {
-            break;
-        }
-        const rawData = text.slice(0, index + delimiters[i].right.length);
-        const math = amsRegex.test(rawData)
-            ? rawData
-            : text.slice(delimiters[i].left.length, index);
-        data.push({
-            type: "math",
-            data: math,
-            rawData,
-            display: delimiters[i].display,
-        });
-        text = text.slice(index + delimiters[i].right.length);
-    }
-
-    if (text !== "") {
-        data.push({
-            type: "text",
-            data: text,
-        });
-    }
-
-    return data;
-};
-
-export default splitAtDelimiters;

package/plugin/node_modules/katex/contrib/auto-render/test/auto-render-spec.ts

@@ -1,371 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import splitAtDelimiters from "../splitAtDelimiters";
-import renderMathInElement from "../auto-render";
-import type {
-    DelimiterSpec,
-    SplitAtDelimiterData,
-} from "../splitAtDelimiters";
-
-beforeEach(function() {
-    expect.extend({
-        toSplitInto: function(
-            actual: string,
-            result: SplitAtDelimiterData[],
-            delimiters: DelimiterSpec[],
-        ) {
-            const message = {
-                pass: true,
-                message: () => "'" + actual + "' split correctly",
-            };
-
-            const split =
-                  splitAtDelimiters(actual, delimiters);
-
-            if (split.length !== result.length) {
-                message.pass = false;
-                message.message = () => "Different number of splits: " +
-                    split.length + " vs. " + result.length + " (" +
-                    JSON.stringify(split) + " vs. " +
-                    JSON.stringify(result) + ")";
-                return message;
-            }
-
-            for (let i = 0; i < split.length; i++) {
-                const real = split[i];
-                const correct = result[i];
-
-                let good = true;
-                let diff = "";
-
-                if (real.type !== correct.type) {
-                    good = false;
-                    diff = "type";
-                } else if (real.data !== correct.data) {
-                    good = false;
-                    diff = "data";
-                } else if (real.display !== correct.display) {
-                    good = false;
-                    diff = "display";
-                }
-
-                if (!good) {
-                    message.pass = false;
-                    message.message = () => "Difference at split " +
-                        (i + 1) + ": " + JSON.stringify(real) +
-                        " vs. " + JSON.stringify(correct) +
-                        " (" + diff + " differs)";
-                    break;
-                }
-            }
-
-            return message;
-        },
-    });
-});
-
-describe("A delimiter splitter", function() {
-    it("doesn't split when there are no delimiters", function() {
-        expect("hello").toSplitInto(
-            [
-                {type: "text", data: "hello"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("doesn't create a math node with only one left delimiter", function() {
-        expect("hello ( world").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "text", data: "( world"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("doesn't split when there's only a right delimiter", function() {
-        expect("hello ) world").toSplitInto(
-            [
-                {type: "text", data: "hello ) world"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("splits when there are both delimiters", function() {
-        expect("hello ( world ) boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "( world )", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("splits on multi-character delimiters", function() {
-        expect("hello [[ world ]] boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "[[ world ]]", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "[[", right: "]]", display: false},
-            ]);
-        expect("hello \\begin{equation} world \\end{equation} boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: "\\begin{equation} world \\end{equation}",
-                    rawData: "\\begin{equation} world \\end{equation}",
-                    display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "\\begin{equation}", right: "\\end{equation}",
-                    display: false},
-            ]);
-    });
-
-    it("splits multiple times", function() {
-        expect("hello ( world ) boo ( more ) stuff").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "( world )", display: false},
-                {type: "text", data: " boo "},
-                {type: "math", data: " more ",
-                    rawData: "( more )", display: false},
-                {type: "text", data: " stuff"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("leaves the ending when there's only a left delimiter", function() {
-        expect("hello ( world ) boo ( left").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "( world )", display: false},
-                {type: "text", data: " boo "},
-                {type: "text", data: "( left"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("doesn't split when close delimiters are in {}s", function() {
-        expect("hello ( world { ) } ) boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world { ) } ",
-                    rawData: "( world { ) } )", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-
-        expect("hello ( world { { } ) } ) boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world { { } ) } ",
-                    rawData: "( world { { } ) } )", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-    });
-
-    it("correctly processes sequences of $..$", function() {
-        expect("$hello$$world$$boo$").toSplitInto(
-            [
-                {type: "math", data: "hello",
-                    rawData: "$hello$", display: false},
-                {type: "math", data: "world",
-                    rawData: "$world$", display: false},
-                {type: "math", data: "boo",
-                    rawData: "$boo$", display: false},
-            ],
-            [
-                {left: "$", right: "$", display: false},
-            ]);
-    });
-
-    it("doesn't split at escaped delimiters", function() {
-        expect("hello ( world \\) ) boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world \\) ",
-                    rawData: "( world \\) )", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "(", right: ")", display: false},
-            ]);
-
-        /* TODO(emily): make this work maybe?
-           expect("hello \\( ( world ) boo").toSplitInto(
-           "(", ")",
-           [
-           {type: "text", data: "hello \\( "},
-           {type: "math", data: " world ",
-           rawData: "( world )", display: false},
-           {type: "text", data: " boo"},
-           ]);
-        */
-    });
-
-    it("splits when the right and left delimiters are the same", function() {
-        expect("hello $ world $ boo").toSplitInto(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "$ world $", display: false},
-                {type: "text", data: " boo"},
-            ],
-            [
-                {left: "$", right: "$", display: false},
-            ]);
-    });
-
-    it("ignores \\$", function() {
-        expect("$x = \\$5$").toSplitInto(
-            [
-                {type: "math", data: "x = \\$5",
-                    rawData: "$x = \\$5$", display: false},
-            ],
-            [
-                {left: "$", right: "$", display: false},
-            ]);
-    });
-
-    it("remembers which delimiters are display-mode", function() {
-        const startData = "hello ( world ) boo";
-
-        expect(splitAtDelimiters(startData,
-                                 [{left:"(", right:")", display:true}])).toEqual(
-            [
-                {type: "text", data: "hello "},
-                {type: "math", data: " world ",
-                    rawData: "( world )", display: true},
-                {type: "text", data: " boo"},
-            ]);
-    });
-
-    it("handles nested delimiters irrespective of order", function() {
-        expect(splitAtDelimiters("$\\fbox{\\(hi\\)}$",
-            [
-                                     {left:"\\(", right:"\\)", display:false},
-                                     {left:"$", right:"$", display:false},
-            ])).toEqual(
-            [
-                {type: "math", data: "\\fbox{\\(hi\\)}",
-                    rawData: "$\\fbox{\\(hi\\)}$", display: false},
-            ]);
-        expect(splitAtDelimiters("\\(\\fbox{$hi$}\\)",
-            [
-                {left:"\\(", right:"\\)", display:false},
-                {left:"$", right:"$", display:false},
-            ])).toEqual(
-            [
-                {type: "math", data: "\\fbox{$hi$}",
-                    rawData: "\\(\\fbox{$hi$}\\)", display: false},
-            ]);
-    });
-
-    it("handles a mix of $ and $$", function() {
-        expect(splitAtDelimiters("$hello$world$$boo$$",
-            [
-                {left:"$$", right:"$$", display:true},
-                {left:"$", right:"$", display:false},
-            ])).toEqual(
-            [
-                {type: "math", data: "hello",
-                    rawData: "$hello$", display: false},
-                                         {type: "text", data: "world"},
-                {type: "math", data: "boo",
-                    rawData: "$$boo$$", display: true},
-            ]);
-        expect(splitAtDelimiters("$hello$$world$$$boo$$",
-            [
-                {left:"$$", right:"$$", display:true},
-                {left:"$", right:"$", display:false},
-            ])).toEqual(
-            [
-                {type: "math", data: "hello",
-                    rawData: "$hello$", display: false},
-                {type: "math", data: "world",
-                    rawData: "$world$", display: false},
-                {type: "math", data: "boo",
-                    rawData: "$$boo$$", display: true},
-            ]);
-    });
-});
-
-describe("Pre-process callback", function() {
-    it("replace `-squared` with `^2 `", function() {
-        const el1 = document.createElement('div');
-        el1.textContent = 'Circle equation: $x-squared + y-squared = r-squared$.';
-        const el2 = document.createElement('div');
-        el2.textContent = 'Circle equation: $x^2 + y^2 = r^2$.';
-        const delimiters = [{left: "$", right: "$", display: false}];
-        renderMathInElement(el1, {
-            delimiters,
-            preProcess: math => math.replace(/-squared/g, '^2'),
-        });
-        renderMathInElement(el2, {delimiters});
-        expect(el1.innerHTML).toEqual(el2.innerHTML);
-    });
-});
-
-describe("Parse adjacent text nodes", function() {
-    it("parse adjacent text nodes with math", function() {
-        const textNodes = ['\\[',
-            'x^2 + y^2 = r^2',
-            '\\]'];
-        const el = document.createElement('div');
-        for (let i = 0; i < textNodes.length; i++) {
-            const txt = document.createTextNode(textNodes[i]);
-            el.appendChild(txt);
-        }
-        const el2 = document.createElement('div');
-        const txt = document.createTextNode(textNodes.join(''));
-        el2.appendChild(txt);
-        const delimiters = [{left: "\\[", right: "\\]", display: true}];
-        renderMathInElement(el, {delimiters});
-        renderMathInElement(el2, {delimiters});
-        expect(el).toStrictEqual(el2);
-    });
-
-    it("parse adjacent text nodes without math", function() {
-        const textNodes = ['Lorem ipsum dolor',
-            'sit amet',
-            'consectetur adipiscing elit'];
-        const el = document.createElement('div');
-        for (let i = 0; i < textNodes.length; i++) {
-            const txt = document.createTextNode(textNodes[i]);
-            el.appendChild(txt);
-        }
-        const el2 = document.createElement('div');
-        for (let i = 0; i < textNodes.length; i++) {
-            const txt = document.createTextNode(textNodes[i]);
-            el2.appendChild(txt);
-        }
-        const delimiters = [{left: "\\[", right: "\\]", display: true}];
-        renderMathInElement(el, {delimiters});
-        expect(el).toStrictEqual(el2);
-    });
-});

package/plugin/node_modules/katex/contrib/copy-tex/README.md

@@ -1,39 +0,0 @@
-# Copy-tex extension
-
-This extension modifies the copy/paste behavior in any browser supporting the
-[Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent)
-so that, when selecting and copying KaTeX-rendered elements, the text
-content of the resulting clipboard renders KaTeX elements as their LaTeX source
-surrounded by specified delimiters.  (The HTML content of the resulting
-clipboard remains the selected HTML content, as it normally would.)
-The default delimiters are `$...$` for inline math and `$$...$$` for display
-math, but you can easy switch them to e.g. `\(...\)` and `\[...\]` by
-modifying `copyDelimiters` in [the source code](copy-tex.js).
-Note that a selection containing part of a KaTeX formula gets extended to
-include the entire KaTeX formula.
-
-## Usage
-
-This extension isn't part of KaTeX proper, so the script should be separately
-included in the page.
-
-```html
-<script src="https://cdn.jsdelivr.net/npm/katex@0.16.47/dist/contrib/copy-tex.min.js" integrity="sha384-Pe2JWbaShhSRT0SESJ9XLPeAsi4yrNi7r/CiH0Coq7giBjK5a6Ae7XcybE8rNlQP" crossorigin="anonymous"></script>
-```
-
-(Note that, as of KaTeX 0.16.0, there is no longer a corresponding CSS file.)
-
-See [index.html](index.html) for an example.
-(To run this example from a clone of the repository, run `yarn start`
-in the root KaTeX directory, and then visit
-http://localhost:7936/contrib/copy-tex/index.html
-with your web browser.)
-
-If you want to build your own custom copy handler based on this one,
-copy the `copy-tex.js` into your codebase and replace the `require`
-statement with `require('katex/contrib/copy-tex/katex2tex.js')`.
-
-ECMAScript module is also available:
-```html
-<script type="module" src="https://cdn.jsdelivr.net/npm/katex@0.16.47/dist/contrib/copy-tex.mjs" integrity="sha384-PTy3nbMSATx5Ifo/k1ErbnbMVEp3koLGaqTD+zBo5H0fPFue/mKr1M3//74Fu6Tf" crossorigin="anonymous"></script>
-```

package/plugin/node_modules/katex/contrib/copy-tex/copy-tex.ts

@@ -1,49 +0,0 @@
-import katexReplaceWithTex from "./katex2tex";
-
-// Return <div class="katex"> element containing node, or null if not found.
-function closestKatex(node: Node): Element | null | undefined {
-    // If node is a Text Node, for example, go up to containing Element,
-    // where we can apply the `closest` method.
-    const element: Element | null | undefined =
-        (node instanceof Element ? node : node.parentElement);
-    return element && element.closest('.katex');
-}
-
-// Global copy handler to modify behavior on/within .katex elements.
-document.addEventListener('copy', function(event: ClipboardEvent) {
-    const selection = window.getSelection();
-    if (!selection || selection.isCollapsed || !event.clipboardData) {
-        return; // default action OK if selection is empty or unchangeable
-    }
-    const clipboardData = event.clipboardData;
-    const range = selection.getRangeAt(0);
-
-    // When start point is within a formula, expand to entire formula.
-    const startKatex = closestKatex(range.startContainer);
-    if (startKatex) {
-        range.setStartBefore(startKatex);
-    }
-
-    // Similarly, when end point is within a formula, expand to entire formula.
-    const endKatex = closestKatex(range.endContainer);
-    if (endKatex) {
-        range.setEndAfter(endKatex);
-    }
-
-    const fragment = range.cloneContents();
-    if (!fragment.querySelector('.katex-mathml')) {
-        return; // default action OK if no .katex-mathml elements
-    }
-
-    const htmlContents = Array.prototype.map.call(fragment.childNodes,
-        (el) => (el instanceof Text ? el.textContent : el.outerHTML)
-    ).join('');
-
-    // Preserve usual HTML copy/paste behavior.
-    clipboardData.setData('text/html', htmlContents);
-    // Rewrite plain-text version.
-    clipboardData.setData('text/plain',
-        katexReplaceWithTex(fragment).textContent);
-    // Prevent normal copy handling.
-    event.preventDefault();
-});

package/plugin/node_modules/katex/contrib/copy-tex/index.html

@@ -1,38 +0,0 @@
-<!DOCTYPE html>
-<!--To run this example from a clone of the repository, run `yarn start`
-    in the root KaTeX directory and then visit with your web browser:
-    http://localhost:7936/contrib/copy-tex/index.html
-  -->
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Copy-tex test</title>
-    <script src="/katex.js" type="text/javascript"></script>
-    <script src="/contrib/auto-render.js" type="text/javascript"></script>
-    <script src="/contrib/copy-tex.js" type="text/javascript"></script>
-    <style type="text/css">
-      body {
-          margin: 0px;
-          padding: 0px;
-          font-size: 36px;
-      }
-
-      #test > .blue {
-          color: blue;
-      }
-    </style>
-  </head>
-  <body>
-    <h1>Copy-tex test</h1>
-    <h2>Try copy/pasting some of the text below!</h2>
-    <p>
-    Here is some \(\KaTeX\) math: $$ x^2+y^2=z^2 $$
-    The variables are \(x\), \(y\), and \(z\),
-    which are all in \(\mathbb{R}^+\).
-    Q.E.D.
-    </p>
-    <script>
-      renderMathInElement(document.body);
-    </script>
-  </body>
-</html>

package/plugin/node_modules/katex/contrib/copy-tex/katex2tex.ts

@@ -1,60 +0,0 @@
-
-export interface CopyDelimiters {
-    inline: [string, string];
-    display: [string, string];
-}
-
-// Set these to how you want inline and display math to be delimited.
-export const defaultCopyDelimiters: CopyDelimiters = {
-    inline: ['$', '$'],    // alternative: ['\(', '\)']
-    display: ['$$', '$$'], // alternative: ['\[', '\]']
-};
-
-// Replace .katex elements with their TeX source (<annotation> element).
-// Modifies fragment in-place.  Useful for writing your own 'copy' handler,
-// as in copy-tex.js.
-export function katexReplaceWithTex(
-    fragment: DocumentFragment,
-    copyDelimiters: CopyDelimiters = defaultCopyDelimiters
-): DocumentFragment {
-    // Remove .katex-html blocks that are preceded by .katex-mathml blocks
-    // (which will get replaced below).
-    const katexHtml = fragment.querySelectorAll('.katex-mathml + .katex-html');
-    for (let i = 0; i < katexHtml.length; i++) {
-        const element = katexHtml[i];
-        if (element.remove) {
-            element.remove();
-        } else if (element.parentNode) {
-            element.parentNode.removeChild(element);
-        }
-    }
-    // Replace .katex-mathml elements with their annotation (TeX source)
-    // descendant, with inline delimiters.
-    const katexMathml = fragment.querySelectorAll('.katex-mathml');
-    for (let i = 0; i < katexMathml.length; i++) {
-        const element = katexMathml[i];
-        const texSource = element.querySelector('annotation');
-        if (texSource) {
-            if (element.replaceWith) {
-                element.replaceWith(texSource);
-            } else if (element.parentNode) {
-                element.parentNode.replaceChild(texSource, element);
-            }
-            texSource.innerHTML = copyDelimiters.inline[0] +
-                texSource.innerHTML + copyDelimiters.inline[1];
-        }
-    }
-    // Switch display math to display delimiters.
-    const displays = fragment.querySelectorAll('.katex-display annotation');
-    for (let i = 0; i < displays.length; i++) {
-        const element = displays[i];
-        element.innerHTML = copyDelimiters.display[0] +
-            element.innerHTML.substr(copyDelimiters.inline[0].length,
-                element.innerHTML.length - copyDelimiters.inline[0].length
-                - copyDelimiters.inline[1].length)
-            + copyDelimiters.display[1];
-    }
-    return fragment;
-}
-
-export default katexReplaceWithTex;