@markupme/core 0.1.0 → 0.1.1

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,37 @@
+# Third-party notices
+
+`@markupme/core` contains code ported to TypeScript from these MIT-licensed projects:
+
+| File | Ported from | Copyright |
+| ---- | ----------- | --------- |
+| `src/render/katex.ts` | [rehype-katex](https://github.com/remarkjs/remark-math/tree/main/packages/rehype-katex) 7.0.1 | Copyright (c) Junyoung Choi <fluke8259@gmail.com> |
+| `src/plugins/math.ts` | [remark-math](https://github.com/remarkjs/remark-math/tree/main/packages/remark-math) 6.0.0 | Copyright (c) Junyoung Choi <fluke8259@gmail.com> |
+| `src/plugins/math-syntax.ts` | [micromark-extension-math](https://github.com/micromark/micromark-extension-math) 3.1.0 | Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com> |
+
+All three are distributed under the MIT License:
+
+```text
+(The MIT License)
+
+Copyright (c) Junyoung Choi <fluke8259@gmail.com>
+Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```

package/dist/parse.js

@@ -1,13 +1,13 @@
 import remarkDirective from 'remark-directive';
 import remarkFrontmatter from 'remark-frontmatter';
 import remarkGfm from 'remark-gfm';
-import remarkMath from 'remark-math';
 import remarkParse from 'remark-parse';
 import { unified } from 'unified';
 import { annotateAlerts } from './plugins/alerts.js';
 import { normalizeDirectives } from './plugins/directives.js';
 import { readFrontmatter } from './plugins/frontmatter.js';
 import { addHeadingIds } from './plugins/headings.js';
+import { remarkMath } from './plugins/math.js';
 import { insertToc } from './plugins/toc.js';
 import { SCHEMA_VERSION, } from './types.js';
 /** Syntax extensions shared by the parser and the serializer, so round trips keep every construct. */

package/dist/plugins/math-syntax.d.ts

@@ -0,0 +1,20 @@
+import type { Extension } from 'micromark-util-types';
+declare module 'micromark-util-types' {
+    interface TokenTypeMap {
+        mathFlow: 'mathFlow';
+        mathFlowFence: 'mathFlowFence';
+        mathFlowFenceMeta: 'mathFlowFenceMeta';
+        mathFlowFenceSequence: 'mathFlowFenceSequence';
+        mathFlowValue: 'mathFlowValue';
+        mathText: 'mathText';
+        mathTextData: 'mathTextData';
+        mathTextPadding: 'mathTextPadding';
+        mathTextSequence: 'mathTextSequence';
+    }
+}
+export interface MathSyntaxOptions {
+    /** Whether `$x$` (one dollar) is text math. Default `true`. */
+    singleDollarTextMath?: boolean | null | undefined;
+}
+/** micromark extension for math syntax. */
+export declare function mathSyntax(options?: MathSyntaxOptions | null): Extension;

package/dist/plugins/math-syntax.js

@@ -0,0 +1,279 @@
+/**
+ * Math syntax for micromark (`$$` flow math and `$` text math), ported to TypeScript from
+ * micromark-extension-math 3.1.0 (`lib/syntax.js`, `lib/math-flow.js`, `lib/math-text.js`).
+ * Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>, MIT; full notice in THIRD-PARTY-NOTICES.md.
+ * https://github.com/micromark/micromark-extension-math
+ *
+ * Why it lives here: micromark-extension-math (and remark-math, which depends on it) declares
+ * `katex ^0.16.0` for its HTML compiler, which MarkupMe never uses. npm ignores our root
+ * `overrides` for installed packages, so depending on it gave every consumer a vulnerable
+ * KaTeX (GHSA-238p-pmpm-9mq7, MKP-7). Only the tokenizers are ported; behaviour is unchanged.
+ */
+import { factorySpace } from 'micromark-factory-space';
+import { markdownLineEnding } from 'micromark-util-character';
+const DOLLAR = 36;
+const SPACE = 32;
+/** micromark extension for math syntax. */
+export function mathSyntax(options) {
+    return {
+        flow: { [DOLLAR]: mathFlow },
+        text: { [DOLLAR]: mathText(options) },
+    };
+}
+// ---------------------------------------------------------------------------------------------
+// Flow math: $$ … $$
+const mathFlow = {
+    tokenize: tokenizeMathFenced,
+    concrete: true,
+    name: 'mathFlow',
+};
+const nonLazyContinuation = {
+    tokenize: tokenizeNonLazyContinuation,
+    partial: true,
+};
+function tokenizeMathFenced(effects, ok, nok) {
+    const self = this;
+    const tail = self.events[self.events.length - 1];
+    const initialSize = tail && tail[1].type === 'linePrefix' ? tail[2].sliceSerialize(tail[1], true).length : 0;
+    let sizeOpen = 0;
+    return start;
+    function start(code) {
+        effects.enter('mathFlow');
+        effects.enter('mathFlowFence');
+        effects.enter('mathFlowFenceSequence');
+        return sequenceOpen(code);
+    }
+    function sequenceOpen(code) {
+        if (code === DOLLAR) {
+            effects.consume(code);
+            sizeOpen++;
+            return sequenceOpen;
+        }
+        if (sizeOpen < 2)
+            return nok(code);
+        effects.exit('mathFlowFenceSequence');
+        return factorySpace(effects, metaBefore, 'whitespace')(code);
+    }
+    function metaBefore(code) {
+        if (code === null || markdownLineEnding(code))
+            return metaAfter(code);
+        effects.enter('mathFlowFenceMeta');
+        effects.enter('chunkString', { contentType: 'string' });
+        return meta(code);
+    }
+    function meta(code) {
+        if (code === null || markdownLineEnding(code)) {
+            effects.exit('chunkString');
+            effects.exit('mathFlowFenceMeta');
+            return metaAfter(code);
+        }
+        if (code === DOLLAR)
+            return nok(code);
+        effects.consume(code);
+        return meta;
+    }
+    function metaAfter(code) {
+        effects.exit('mathFlowFence');
+        if (self.interrupt)
+            return ok(code);
+        return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    function beforeNonLazyContinuation(code) {
+        return effects.attempt({ tokenize: tokenizeClosingFence, partial: true }, after, contentStart)(code);
+    }
+    function contentStart(code) {
+        return (initialSize
+            ? factorySpace(effects, beforeContentChunk, 'linePrefix', initialSize + 1)
+            : beforeContentChunk)(code);
+    }
+    function beforeContentChunk(code) {
+        if (code === null)
+            return after(code);
+        if (markdownLineEnding(code)) {
+            return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+        }
+        effects.enter('mathFlowValue');
+        return contentChunk(code);
+    }
+    function contentChunk(code) {
+        if (code === null || markdownLineEnding(code)) {
+            effects.exit('mathFlowValue');
+            return beforeContentChunk(code);
+        }
+        effects.consume(code);
+        return contentChunk;
+    }
+    function after(code) {
+        effects.exit('mathFlow');
+        return ok(code);
+    }
+    function tokenizeClosingFence(effects, ok, nok) {
+        let size = 0;
+        return factorySpace(effects, beforeSequenceClose, 'linePrefix', self.parser.constructs.disable.null?.includes('codeIndented') ? undefined : 4);
+        function beforeSequenceClose(code) {
+            effects.enter('mathFlowFence');
+            effects.enter('mathFlowFenceSequence');
+            return sequenceClose(code);
+        }
+        function sequenceClose(code) {
+            if (code === DOLLAR) {
+                size++;
+                effects.consume(code);
+                return sequenceClose;
+            }
+            if (size < sizeOpen)
+                return nok(code);
+            effects.exit('mathFlowFenceSequence');
+            return factorySpace(effects, afterSequenceClose, 'whitespace')(code);
+        }
+        function afterSequenceClose(code) {
+            if (code === null || markdownLineEnding(code)) {
+                effects.exit('mathFlowFence');
+                return ok(code);
+            }
+            return nok(code);
+        }
+    }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+    const self = this;
+    return start;
+    function start(code) {
+        if (code === null)
+            return ok(code);
+        effects.enter('lineEnding');
+        effects.consume(code);
+        effects.exit('lineEnding');
+        return lineStart;
+    }
+    function lineStart(code) {
+        return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// Text math: $ … $ and $$ … $$ inline
+function mathText(options) {
+    let single = options?.singleDollarTextMath;
+    if (single === null || single === undefined)
+        single = true;
+    return {
+        tokenize: tokenizeMathText,
+        resolve: resolveMathText,
+        previous,
+        name: 'mathText',
+    };
+    function tokenizeMathText(effects, ok, nok) {
+        let sizeOpen = 0;
+        let size = 0;
+        let token;
+        return start;
+        function start(code) {
+            effects.enter('mathText');
+            effects.enter('mathTextSequence');
+            return sequenceOpen(code);
+        }
+        function sequenceOpen(code) {
+            if (code === DOLLAR) {
+                effects.consume(code);
+                sizeOpen++;
+                return sequenceOpen;
+            }
+            if (sizeOpen < 2 && !single)
+                return nok(code);
+            effects.exit('mathTextSequence');
+            return between(code);
+        }
+        function between(code) {
+            if (code === null)
+                return nok(code);
+            if (code === DOLLAR) {
+                token = effects.enter('mathTextSequence');
+                size = 0;
+                return sequenceClose(code);
+            }
+            if (code === SPACE) {
+                effects.enter('space');
+                effects.consume(code);
+                effects.exit('space');
+                return between;
+            }
+            if (markdownLineEnding(code)) {
+                effects.enter('lineEnding');
+                effects.consume(code);
+                effects.exit('lineEnding');
+                return between;
+            }
+            effects.enter('mathTextData');
+            return data(code);
+        }
+        function data(code) {
+            if (code === null || code === SPACE || code === DOLLAR || markdownLineEnding(code)) {
+                effects.exit('mathTextData');
+                return between(code);
+            }
+            effects.consume(code);
+            return data;
+        }
+        function sequenceClose(code) {
+            if (code === DOLLAR) {
+                effects.consume(code);
+                size++;
+                return sequenceClose;
+            }
+            if (size === sizeOpen) {
+                effects.exit('mathTextSequence');
+                effects.exit('mathText');
+                return ok(code);
+            }
+            // More or fewer dollars than the opening sequence: it is data.
+            if (token)
+                token.type = 'mathTextData';
+            return data(code);
+        }
+    }
+}
+const resolveMathText = (events) => {
+    let tailExitIndex = events.length - 4;
+    let headEnterIndex = 3;
+    let index;
+    let enter;
+    const at = (i) => events[i][1];
+    // A space or line ending on both sides of data is padding.
+    if ((at(headEnterIndex).type === 'lineEnding' || at(headEnterIndex).type === 'space') &&
+        (at(tailExitIndex).type === 'lineEnding' || at(tailExitIndex).type === 'space')) {
+        index = headEnterIndex;
+        while (++index < tailExitIndex) {
+            if (at(index).type === 'mathTextData') {
+                at(tailExitIndex).type = 'mathTextPadding';
+                at(headEnterIndex).type = 'mathTextPadding';
+                headEnterIndex += 2;
+                tailExitIndex -= 2;
+                break;
+            }
+        }
+    }
+    // Merge adjacent spaces and data.
+    index = headEnterIndex - 1;
+    tailExitIndex++;
+    while (++index <= tailExitIndex) {
+        if (enter === undefined) {
+            if (index !== tailExitIndex && at(index).type !== 'lineEnding')
+                enter = index;
+        }
+        else if (index === tailExitIndex || at(index).type === 'lineEnding') {
+            at(enter).type = 'mathTextData';
+            if (index !== enter + 2) {
+                at(enter).end = at(index - 1).end;
+                events.splice(enter + 2, index - enter - 2);
+                tailExitIndex -= index - enter - 2;
+                index = enter + 2;
+            }
+            enter = undefined;
+        }
+    }
+    return events;
+};
+const previous = function (code) {
+    // If there is a previous code, there will always be a tail.
+    return (code !== DOLLAR || this.events[this.events.length - 1][1].type === 'characterEscape');
+};

package/dist/plugins/math.d.ts

@@ -0,0 +1,2 @@
+import type { Processor } from 'unified';
+export declare function remarkMath(this: Processor): undefined;

package/dist/plugins/math.js

@@ -0,0 +1,17 @@
+/**
+ * remark plugin for math syntax: the in-tree equivalent of remark-math 6.0.0 (MIT,
+ * https://github.com/remarkjs/remark-math), using `mdast-util-math` and the ported tokenizers in
+ * `math-syntax.ts`. See that file for why remark-math is no longer a dependency (MKP-7).
+ * Copyright (c) Junyoung Choi <fluke8259@gmail.com>, MIT; full notice in THIRD-PARTY-NOTICES.md.
+ */
+import { mathFromMarkdown, mathToMarkdown } from 'mdast-util-math';
+import { mathSyntax } from './math-syntax.js';
+export function remarkMath() {
+    const data = this.data();
+    data.micromarkExtensions ??= [];
+    data.fromMarkdownExtensions ??= [];
+    data.toMarkdownExtensions ??= [];
+    data.micromarkExtensions.push(mathSyntax());
+    data.fromMarkdownExtensions.push(mathFromMarkdown());
+    data.toMarkdownExtensions.push(mathToMarkdown());
+}

package/dist/render/html.js

@@ -1,4 +1,3 @@
-import rehypeKatex from 'rehype-katex';
 import rehypeRaw from 'rehype-raw';
 import rehypeSanitize from 'rehype-sanitize';
 import rehypeStringify from 'rehype-stringify';
@@ -8,6 +7,7 @@ import { visit } from 'unist-util-visit';
 import { presentAlerts } from '../plugins/alerts.js';
 import { presentDirectives } from '../plugins/directives.js';
 import { presentEmoji } from '../plugins/emoji.js';
+import { rehypeKatex } from './katex.js';
 import { markupmeSchema } from './schema.js';
 const CLOBBER = 'user-content-';
 function textOf(node) {
@@ -196,9 +196,7 @@ export async function renderHtml(doc, opts, r, diagnostics) {
         }
     });
     if (opts.math === true)
-        out = (await unified()
-            .use(rehypeKatex, { throwOnError: false })
-            .run(out));
+        out = (await unified().use(rehypeKatex).run(out));
     // Fill slots with trusted HTML.
     visit(out, 'element', (el, i, parent) => {
         const id = el.properties.id;

package/dist/render/katex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * rehype plugin that renders math with KaTeX: the in-tree equivalent of rehype-katex 7.0.1 (MIT,
+ * https://github.com/remarkjs/remark-math), calling the `katex` version this package pins.
+ * Copyright (c) Junyoung Choi <fluke8259@gmail.com>, MIT; full notice in THIRD-PARTY-NOTICES.md.
+ * rehype-katex declares `katex ^0.16.0`, and npm ignores our root `overrides` for installed
+ * packages, so depending on it gave every consumer a vulnerable KaTeX (GHSA-238p-pmpm-9mq7,
+ * MKP-7). Behaviour is unchanged: elements with a `language-math`, `math-display` or
+ * `math-inline` class are replaced by KaTeX output; errors are reported on the file and
+ * rendered in KaTeX's error style.
+ */
+import type { Root } from 'hast';
+import type { VFile } from 'vfile';
+export declare function rehypeKatex(): (tree: Root, file: VFile) => undefined;

package/dist/render/katex.js

@@ -0,0 +1,79 @@
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic';
+import { toText } from 'hast-util-to-text';
+import katex from 'katex';
+import { SKIP, visitParents } from 'unist-util-visit-parents';
+export function rehypeKatex() {
+    return (tree, file) => {
+        visitParents(tree, 'element', (element, parents) => {
+            const classes = Array.isArray(element.properties.className)
+                ? element.properties.className
+                : [];
+            // ```math fenced code
+            const languageMath = classes.includes('language-math');
+            // $$ flow math
+            const mathDisplay = classes.includes('math-display');
+            // $ text math
+            const mathInline = classes.includes('math-inline');
+            let displayMode = mathDisplay;
+            if (!languageMath && !mathDisplay && !mathInline)
+                return;
+            let parent = parents[parents.length - 1];
+            let scope = element;
+            // ```math: replace the <pre> and use display mode.
+            if (element.tagName === 'code' &&
+                languageMath &&
+                parent &&
+                parent.type === 'element' &&
+                parent.tagName === 'pre') {
+                scope = parent;
+                parent = parents[parents.length - 2];
+                displayMode = true;
+            }
+            if (!parent)
+                return;
+            const value = toText(scope, { whitespace: 'pre' });
+            let result;
+            try {
+                result = katex.renderToString(value, { displayMode, throwOnError: true });
+            }
+            catch (error) {
+                const cause = error;
+                file.message('Could not render math with KaTeX', {
+                    ancestors: [...parents, element],
+                    cause,
+                    place: element.position,
+                    ruleId: cause.name.toLowerCase(),
+                    source: 'rehype-katex',
+                });
+                try {
+                    result = katex.renderToString(value, {
+                        displayMode,
+                        strict: 'ignore',
+                        throwOnError: false,
+                    });
+                }
+                catch {
+                    // KaTeX's error markup, for errors it does not handle itself.
+                    result = [
+                        {
+                            type: 'element',
+                            tagName: 'span',
+                            properties: {
+                                className: ['katex-error'],
+                                style: 'color:#cc0000',
+                                title: String(error),
+                            },
+                            children: [{ type: 'text', value }],
+                        },
+                    ];
+                }
+            }
+            if (typeof result === 'string') {
+                result = fromHtmlIsomorphic(result, { fragment: true }).children;
+            }
+            const index = parent.children.indexOf(scope);
+            parent.children.splice(index, 1, ...result);
+            return SKIP;
+        });
+    };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.1.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markupme/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "MarkupMe core: standards-first Markdown (CommonMark + GFM) parsing, a typed document model, safe HTML rendering, Markdown serialization, linting and TOC on unified/remark.",
   "license": "MIT",
   "author": "Yarlis AI Solutions",
@@ -34,6 +34,7 @@
   },
   "files": [
     "dist",
+    "THIRD-PARTY-NOTICES.md",
     "!dist/**/*.tsbuildinfo"
   ],
   "publishConfig": {
@@ -51,23 +52,30 @@
     "@types/unist": "3.0.3",
     "gemoji": "8.1.0",
     "github-slugger": "2.0.0",
+    "hast-util-from-html-isomorphic": "2.0.0",
     "hast-util-sanitize": "5.0.2",
+    "hast-util-to-text": "4.0.2",
+    "katex": "0.19.1",
     "mdast-util-directive": "3.2.0",
+    "mdast-util-math": "3.0.0",
     "mdast-util-to-string": "4.0.0",
-    "rehype-katex": "7.0.1",
+    "micromark-factory-space": "2.1.0",
+    "micromark-util-character": "2.1.1",
+    "micromark-util-types": "2.0.3",
     "rehype-raw": "7.0.0",
     "rehype-sanitize": "6.0.0",
     "rehype-stringify": "10.0.1",
     "remark-directive": "4.0.0",
     "remark-frontmatter": "5.0.0",
     "remark-gfm": "4.0.1",
-    "remark-math": "6.0.0",
     "remark-parse": "11.0.0",
     "remark-rehype": "11.1.2",
     "remark-stringify": "11.0.0",
     "smol-toml": "1.9.1",
     "unified": "11.0.5",
     "unist-util-visit": "5.2.0",
+    "unist-util-visit-parents": "6.0.2",
+    "vfile": "6.0.3",
     "yaml": "2.9.1"
   },
   "engines": {