@rse/ase 0.0.30 → 0.0.32

package/plugin/node_modules/katex/katex.ts

@@ -0,0 +1,250 @@
+/* eslint no-console:0 */
+/**
+ * This is the main entry point for KaTeX. Here, we expose functions for
+ * rendering expressions either to DOM nodes or to markup strings.
+ *
+ * We also expose the ParseError class to check if errors thrown from KaTeX are
+ * errors in the expression, or errors in javascript handling.
+ */
+
+import ParseError from "./src/ParseError";
+import Settings, {SETTINGS_SCHEMA} from "./src/Settings";
+
+import {buildTree, buildHTMLTree} from "./src/buildTree";
+import parseTree from "./src/parseTree";
+import {makeSpan} from "./src/buildCommon";
+import {
+    Span,
+    Anchor,
+    SymbolNode,
+    SvgNode,
+    PathNode,
+    LineNode,
+} from "./src/domTree";
+
+import type {SettingsOptions} from "./src/Settings";
+import type {AnyParseNode} from "./src/parseNode";
+import type {DomSpan} from "./src/domTree";
+
+import {defineSymbol} from './src/symbols';
+import defineFunction from './src/defineFunction';
+import defineMacro from './src/defineMacro';
+import {setFontMetrics} from './src/fontMetrics';
+
+declare let __VERSION__: string;
+
+/**
+ * Parse and build an expression, and place that expression in the DOM node
+ * given.
+ */
+let render: (
+    expression: string,
+    baseNode: Node,
+    options: SettingsOptions,
+) => void = function(
+    expression: string,
+    baseNode: Node,
+    options: SettingsOptions,
+) {
+    baseNode.textContent = "";
+    const node = renderToDomTree(expression, options).toNode();
+    baseNode.appendChild(node);
+};
+
+// KaTeX's styles don't work properly in quirks mode. Print out an error, and
+// disable rendering.
+if (typeof document !== "undefined") {
+    if (document.compatMode !== "CSS1Compat") {
+        typeof console !== "undefined" && console.warn(
+            "Warning: KaTeX doesn't work in quirks mode. Make sure your " +
+                "website has a suitable doctype.");
+
+        render = function() {
+            throw new ParseError("KaTeX doesn't work in quirks mode.");
+        };
+    }
+}
+
+/**
+ * Parse and build an expression, and return the markup for that.
+ */
+const renderToString = function(
+    expression: string,
+    options: SettingsOptions,
+): string {
+    const markup = renderToDomTree(expression, options).toMarkup();
+    return markup;
+};
+
+/**
+ * Parse an expression and return the parse tree.
+ */
+const generateParseTree = function(
+    expression: string,
+    options?: SettingsOptions,
+): AnyParseNode[] {
+    const settings = new Settings(options);
+    return parseTree(expression, settings);
+};
+
+/**
+ * If the given error is a KaTeX ParseError and options.throwOnError is false,
+ * renders the invalid LaTeX as a span with hover title giving the KaTeX
+ * error message.  Otherwise, simply throws the error.
+ */
+const renderError = function(
+    error: unknown,
+    expression: string,
+    options: Settings,
+) {
+    if (options.throwOnError || !(error instanceof ParseError)) {
+        throw error;
+    }
+    const node = makeSpan(["katex-error"],
+        [new SymbolNode(expression)]);
+    node.setAttribute("title", error.toString());
+    node.setAttribute("style", `color:${options.errorColor}`);
+    return node;
+};
+
+/**
+ * Generates and returns the katex build tree. This is used for advanced
+ * use cases (like rendering to custom output).
+ */
+const renderToDomTree = function(
+    expression: string,
+    options: SettingsOptions,
+): DomSpan {
+    const settings = new Settings(options);
+    try {
+        const tree = parseTree(expression, settings);
+        return buildTree(tree, expression, settings);
+    } catch (error) {
+        return renderError(error, expression, settings);
+    }
+};
+
+/**
+ * Generates and returns the katex build tree, with just HTML (no MathML).
+ * This is used for advanced use cases (like rendering to custom output).
+ */
+const renderToHTMLTree = function(
+    expression: string,
+    options: SettingsOptions,
+): DomSpan {
+    const settings = new Settings(options);
+    try {
+        const tree = parseTree(expression, settings);
+        return buildHTMLTree(tree, expression, settings);
+    } catch (error) {
+        return renderError(error, expression, settings);
+    }
+};
+
+const version = __VERSION__;
+
+const __domTree = {
+    Span,
+    Anchor,
+    SymbolNode,
+    SvgNode,
+    PathNode,
+    LineNode,
+};
+
+// ESM exports
+export {
+    version,
+    render,
+    renderToString,
+    ParseError,
+    SETTINGS_SCHEMA,
+    generateParseTree as __parse,
+    renderToDomTree as __renderToDomTree,
+    renderToHTMLTree as __renderToHTMLTree,
+    setFontMetrics as __setFontMetrics,
+    defineSymbol as __defineSymbol,
+    defineFunction as __defineFunction,
+    defineMacro as __defineMacro,
+    __domTree,
+};
+
+// CJS exports and ESM default export
+export default {
+    /**
+     * Current KaTeX version
+     */
+    version,
+    /**
+     * Renders the given LaTeX into an HTML+MathML combination, and adds
+     * it as a child to the specified DOM node.
+     */
+    render,
+    /**
+     * Renders the given LaTeX into an HTML+MathML combination string,
+     * for sending to the client.
+     */
+    renderToString,
+    /**
+     * KaTeX error, usually during parsing.
+     */
+    ParseError,
+    /**
+     * The schema of Settings
+     */
+    SETTINGS_SCHEMA,
+    /**
+     * Parses the given LaTeX into KaTeX's internal parse tree structure,
+     * without rendering to HTML or MathML.
+     *
+     * NOTE: This method is not currently recommended for public use.
+     * The internal tree representation is unstable and is very likely
+     * to change. Use at your own risk.
+     */
+    __parse: generateParseTree,
+    /**
+     * Renders the given LaTeX into an HTML+MathML internal DOM tree
+     * representation, without flattening that representation to a string.
+     *
+     * NOTE: This method is not currently recommended for public use.
+     * The internal tree representation is unstable and is very likely
+     * to change. Use at your own risk.
+     */
+    __renderToDomTree: renderToDomTree,
+    /**
+     * Renders the given LaTeX into an HTML internal DOM tree representation,
+     * without MathML and without flattening that representation to a string.
+     *
+     * NOTE: This method is not currently recommended for public use.
+     * The internal tree representation is unstable and is very likely
+     * to change. Use at your own risk.
+     */
+    __renderToHTMLTree: renderToHTMLTree,
+    /**
+     * extends internal font metrics object with a new object
+     * each key in the new object represents a font name
+    */
+    __setFontMetrics: setFontMetrics,
+    /**
+     * adds a new symbol to builtin symbols table
+     */
+    __defineSymbol: defineSymbol,
+    /**
+     * adds a new function to builtin function list,
+     * which directly produce parse tree elements
+     * and have their own html/mathml builders
+     */
+    __defineFunction: defineFunction,
+    /**
+     * adds a new macro to builtin macro list
+     */
+    __defineMacro: defineMacro,
+    /**
+     * Expose the dom tree node types, which can be useful for type checking nodes.
+     *
+     * NOTE: These methods are not currently recommended for public use.
+     * The internal tree representation is unstable and is very likely
+     * to change. Use at your own risk.
+     */
+    __domTree,
+};

package/plugin/node_modules/katex/package.json

@@ -0,0 +1,198 @@
+{
+  "name": "katex",
+  "version": "0.16.47",
+  "description": "Fast math typesetting for the web.",
+  "main": "dist/katex.js",
+  "types": "types/katex.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./types/katex.d.ts",
+        "default": "./dist/katex.js"
+      },
+      "import": {
+        "types": "./types/katex.d.ts",
+        "default": "./dist/katex.mjs"
+      }
+    },
+    "./contrib/auto-render": {
+      "require": "./dist/contrib/auto-render.js",
+      "import": "./dist/contrib/auto-render.mjs"
+    },
+    "./contrib/mhchem": {
+      "require": "./dist/contrib/mhchem.js",
+      "import": "./dist/contrib/mhchem.mjs"
+    },
+    "./contrib/copy-tex": {
+      "require": "./dist/contrib/copy-tex.js",
+      "import": "./dist/contrib/copy-tex.mjs"
+    },
+    "./contrib/mathtex-script-type": {
+      "require": "./dist/contrib/mathtex-script-type.js",
+      "import": "./dist/contrib/mathtex-script-type.mjs"
+    },
+    "./contrib/render-a11y-string": {
+      "require": "./dist/contrib/render-a11y-string.js",
+      "import": "./dist/contrib/render-a11y-string.mjs"
+    },
+    "./*": "./*"
+  },
+  "homepage": "https://katex.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KaTeX/KaTeX.git"
+  },
+  "funding": [
+    "https://opencollective.com/katex",
+    "https://github.com/sponsors/katex"
+  ],
+  "files": [
+    "katex.ts",
+    "cli.js",
+    "src/",
+    "contrib/",
+    "dist/",
+    "types/"
+  ],
+  "license": "MIT",
+  "packageManager": "yarn@4.1.1",
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-transform-react-jsx": "^7.28.6",
+    "@babel/plugin-transform-runtime": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@babel/preset-react": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@babel/register": "^7.28.6",
+    "@babel/runtime": "^7.28.6",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-babel": "^5.3.1",
+    "@rollup/plugin-commonjs": "^28.0.9",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@stylistic/stylelint-plugin": "^5.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.1",
+    "@typescript-eslint/parser": "^8.59.1",
+    "babel-jest": "^30.2.0",
+    "babel-loader": "^8.2.5",
+    "babel-plugin-istanbul": "^6.1.1",
+    "babel-plugin-preval": "^5.1.0",
+    "babel-plugin-version-inline": "^1.0.0",
+    "benchmark": "^2.1.4",
+    "browserslist": "^4.21.3",
+    "caniuse-lite": "^1.0.30001384",
+    "css-loader": "^6.7.1",
+    "cssnano": "^5.1.13",
+    "eslint": "^10.0.3",
+    "eslint-plugin-actions": "^2.0.0",
+    "eslint-plugin-react": "^7.37.5",
+    "fs-extra": "^10.1.0",
+    "globals": "^17.6.0",
+    "got": "^11.8.5",
+    "husky": "^4.3.8",
+    "istanbul-lib-coverage": "^3.2.0",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-reports": "^3.1.5",
+    "jest": "^30.2.0",
+    "jest-diff": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-matcher-utils": "^30.2.0",
+    "jest-message-util": "^30.2.0",
+    "jest-serializer-html": "^7.1.0",
+    "js-yaml": "^4.1.0",
+    "json-stable-stringify": "^1.0.1",
+    "jspngopt": "^0.2.0",
+    "mini-css-extract-plugin": "^2.6.1",
+    "mkdirp": "^1.0.4",
+    "p-retry": "^4.6.2",
+    "pako": "^2.0.4",
+    "postcss": "^8.4.16",
+    "postcss-loader": "^7.0.1",
+    "postcss-preset-env": "^7.8.0",
+    "postcss-scss": "^4.0.9",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.79.2",
+    "sass": "^1.94.2",
+    "sass-loader": "^16.0.6",
+    "selenium-webdriver": "^4.4.0",
+    "semantic-release": "^19.0.5",
+    "sri-toolbox": "^0.2.0",
+    "style-loader": "^3.3.1",
+    "stylelint": "^17.9.1",
+    "stylelint-config-standard": "^40.0.0",
+    "stylelint-scss": "^7.0.0",
+    "terser-webpack-plugin": "^5.3.6",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "webpack": "^5.74.0",
+    "webpack-bundle-analyzer": "^5.0.0",
+    "webpack-cli": "^5.0.0",
+    "webpack-dev-server": "^5.0.0",
+    "webpack-remove-empty-scripts": "^1.0.4"
+  },
+  "bin": "cli.js",
+  "scripts": {
+    "test": "yarn test:lint && yarn test:ts && yarn test:jest",
+    "test:lint": "yarn test:lint:js && yarn test:lint:css",
+    "test:lint:js": "eslint .",
+    "test:lint:css": "stylelint src/styles/katex.scss static/main.css website/static/**/*.css",
+    "test:jest": "jest",
+    "test:jest:watch": "jest --watch",
+    "test:jest:update": "jest --updateSnapshot",
+    "test:jest:coverage": "jest --coverage",
+    "test:screenshots": "yarn test:screenshots:update --verify",
+    "test:screenshots:update": "dockers/screenshotter/screenshotter.sh",
+    "test:perf": "NODE_ENV=test node -e \"require('@babel/register')({extensions:['.js','.ts']}); require('./test/perf-test.ts')\"",
+    "test:ts": "tsc --noEmit",
+    "test:build": "node test/verify-build.js",
+    "clean": "rm -rf dist/ node_modules/",
+    "clean-install": "yarn clean && yarn",
+    "start": "webpack serve --config webpack.dev.js",
+    "analyze": "webpack --config webpack.analyze.js",
+    "build": "rimraf dist/ && mkdirp dist && cp README.md dist && rollup -c --failAfterWarnings && webpack && node update-sri.js package dist/README.md",
+    "build:fonts": "dockers/fonts/buildFonts.sh",
+    "build:metrics": "dockers/fonts/buildMetrics.sh",
+    "watch": "yarn build --watch",
+    "postversion": "yarn dist && node update-sri.js package README.md contrib/*/README.md docs/*.md website/pages/index.html",
+    "semantic-release": "semantic-release",
+    "dist": "yarn build && yarn dist:zip",
+    "dist:zip": "rimraf katex/ katex.tar.gz katex.zip && cp -R dist katex && tar czf katex.tar.gz katex && zip -rq katex.zip katex && rimraf katex/"
+  },
+  "dependencies": {
+    "commander": "^8.3.0"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "yarn test:lint"
+    }
+  },
+  "jest": {
+    "collectCoverageFrom": [
+      "src/**/*.{js,ts}",
+      "contrib/**/*.{js,ts}",
+      "!src/unicodeSymbols.{js,ts}",
+      "!contrib/mhchem/**"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/setup.ts"
+    ],
+    "snapshotSerializers": [
+      "jest-serializer-html"
+    ],
+    "testMatch": [
+      "**/test/*-spec.ts"
+    ],
+    "testEnvironmentOptions": {
+      "url": "http://localhost/"
+    },
+    "transform": {
+      "^.+\\.(js|ts)$": "babel-jest"
+    },
+    "moduleNameMapper": {
+      "^katex$": "<rootDir>/katex.ts"
+    }
+  }
+}

package/plugin/node_modules/katex/src/Lexer.ts

@@ -0,0 +1,121 @@
+/**
+ * The Lexer class handles tokenizing the input in various ways. Since our
+ * parser expects us to be able to backtrack, the lexer allows lexing from any
+ * given starting point.
+ *
+ * Its main exposed function is the `lex` function, which takes a position to
+ * lex from and a type of token to lex. It defers to the appropriate `_innerLex`
+ * function.
+ *
+ * The various `_innerLex` functions perform the actual lexing of different
+ * kinds.
+ */
+
+import ParseError from "./ParseError";
+import SourceLocation from "./SourceLocation";
+import {Token} from "./Token";
+
+import type {LexerInterface} from "./Token";
+import type Settings from "./Settings";
+
+/* The following tokenRegex
+ * - matches typical whitespace (but not NBSP etc.) using its first group
+ * - does not match any control character \x00-\x1f except whitespace
+ * - does not match a bare backslash
+ * - matches any ASCII character except those just mentioned
+ * - does not match the BMP private use area \uE000-\uF8FF
+ * - does not match bare surrogate code units
+ * - matches any BMP character except for those just described
+ * - matches any valid Unicode surrogate pair
+ * - matches a backslash followed by one or more whitespace characters
+ * - matches a backslash followed by one or more letters then whitespace
+ * - matches a backslash followed by any BMP character
+ * Capturing groups:
+ *   [1] regular whitespace
+ *   [2] backslash followed by whitespace
+ *   [3] anything else, which may include:
+ *     [4] left character of \verb*
+ *     [5] left character of \verb
+ *     [6] backslash followed by word, excluding any trailing whitespace
+ * Just because the Lexer matches something doesn't mean it's valid input:
+ * If there is no matching function or symbol definition, the Parser will
+ * still reject the input.
+ */
+const spaceRegexString = "[ \r\n\t]";
+const controlWordRegexString = "\\\\[a-zA-Z@]+";
+const controlSymbolRegexString = "\\\\[^\uD800-\uDFFF]";
+const controlWordWhitespaceRegexString =
+    `(${controlWordRegexString})${spaceRegexString}*`;
+const controlSpaceRegexString = "\\\\(\n|[ \r\t]+\n?)[ \r\t]*";
+const combiningDiacriticalMarkString = "[\u0300-\u036f]";
+export const combiningDiacriticalMarksEndRegex: RegExp =
+    new RegExp(`${combiningDiacriticalMarkString}+$`);
+const tokenRegexString = `(${spaceRegexString}+)|` +  // whitespace
+    `${controlSpaceRegexString}|` +                   // \whitespace
+    "([!-\\[\\]-\u2027\u202A-\uD7FF\uF900-\uFFFF]" +  // single codepoint
+    `${combiningDiacriticalMarkString}*` +            // ...plus accents
+    "|[\uD800-\uDBFF][\uDC00-\uDFFF]" +               // surrogate pair
+    `${combiningDiacriticalMarkString}*` +            // ...plus accents
+    "|\\\\verb\\*([^]).*?\\4" +                       // \verb*
+    "|\\\\verb([^*a-zA-Z]).*?\\5" +                   // \verb unstarred
+    `|${controlWordWhitespaceRegexString}` +          // \macroName + spaces
+    `|${controlSymbolRegexString})`;                  // \\, \', etc.
+
+/** Main Lexer class */
+export default class Lexer implements LexerInterface {
+    input: string;
+    settings: Settings;
+    tokenRegex: RegExp;
+    // Category codes. The lexer only supports comment characters (14) for now.
+    // MacroExpander additionally distinguishes active (13).
+    catcodes: Record<string, number>;
+
+    constructor(input: string, settings: Settings) {
+        // Separate accents from characters
+        this.input = input;
+        this.settings = settings;
+        this.tokenRegex = new RegExp(tokenRegexString, 'g');
+        this.catcodes = {
+            "%": 14, // comment character
+            "~": 13, // active character
+        };
+    }
+
+    setCatcode(char: string, code: number) {
+        this.catcodes[char] = code;
+    }
+
+    /**
+     * This function lexes a single token.
+     */
+    lex(): Token {
+        const input = this.input;
+        const pos = this.tokenRegex.lastIndex;
+        if (pos === input.length) {
+            return new Token("EOF", new SourceLocation(this, pos, pos));
+        }
+        const match = this.tokenRegex.exec(input);
+        if (match === null || match.index !== pos) {
+            throw new ParseError(
+                `Unexpected character: '${input[pos]}'`,
+                new Token(input[pos], new SourceLocation(this, pos, pos + 1)));
+        }
+        const text = match[6] || match[3] || (match[2] ? "\\ " : " ");
+
+        if (this.catcodes[text] === 14) { // comment character
+            const nlIndex = input.indexOf('\n', this.tokenRegex.lastIndex);
+            if (nlIndex === -1) {
+                this.tokenRegex.lastIndex = input.length; // EOF
+                this.settings.reportNonstrict("commentAtEnd",
+                    "% comment has no terminating newline; LaTeX would " +
+                    "fail because of commenting the end of math mode (e.g. $)");
+            } else {
+                this.tokenRegex.lastIndex = nlIndex + 1;
+            }
+            return this.lex();
+        }
+
+        return new Token(text, new SourceLocation(this, pos,
+            this.tokenRegex.lastIndex));
+    }
+}