@rse/ase 0.0.31 → 0.0.32

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

@@ -0,0 +1,79 @@
+import type {CssStyle, HtmlDomNode} from "./domTree";
+import type {MathDomNode} from "./mathMLTree";
+
+
+// To ensure that all nodes have compatible signatures for these methods.
+export interface VirtualNode {
+    toNode(): Node;
+    toMarkup(): string;
+}
+
+function isMathDomNode(node: VirtualNode): node is MathDomNode {
+    return 'toText' in node;
+}
+
+
+/**
+ * This node represents a document fragment, which contains elements, but when
+ * placed into the DOM doesn't have any representation itself. It only contains
+ * children and doesn't have any DOM node properties.
+ */
+export class DocumentFragment<ChildType extends VirtualNode>
+    implements HtmlDomNode, MathDomNode {
+    children: ReadonlyArray<ChildType>;
+    classes: string[];
+    height: number;
+    depth: number;
+    maxFontSize: number;
+    style: CssStyle;          // Never used; needed for satisfying interface.
+
+    constructor(children: ReadonlyArray<ChildType>) {
+        this.children = children;
+        this.classes = [];
+        this.height = 0;
+        this.depth = 0;
+        this.maxFontSize = 0;
+        this.style = {};
+    }
+
+    hasClass(className: string): boolean {
+        return this.classes.includes(className);
+    }
+
+    /** Convert the fragment into a node. */
+    toNode(): Node {
+        const frag = document.createDocumentFragment();
+
+        for (let i = 0; i < this.children.length; i++) {
+            frag.appendChild(this.children[i].toNode());
+        }
+
+        return frag;
+    }
+
+    /** Convert the fragment into HTML markup. */
+    toMarkup(): string {
+        let markup = "";
+
+        // Simply concatenate the markup for the children together.
+        for (let i = 0; i < this.children.length; i++) {
+            markup += this.children[i].toMarkup();
+        }
+
+        return markup;
+    }
+
+    /**
+     * Converts the math node into a string, similar to innerText. Applies to
+     * MathDomNode's only.
+     */
+    toText(): string {
+        return this.children.map((child: ChildType): string => {
+            if (isMathDomNode(child)) {
+                return child.toText();
+            }
+            throw new Error(
+                `Expected MathDomNode with toText, got ${child.constructor.name}`);
+        }).join("");
+    }
+}

package/plugin/node_modules/katex/src/types/fonts.ts

@@ -0,0 +1,73 @@
+// Math font variants.
+export type FontVariant =
+    | "bold"
+    | "bold-italic"
+    | "bold-sans-serif"
+    | "double-struck"
+    | "fraktur"
+    | "italic"
+    | "monospace"
+    | "normal"
+    | "sans-serif"
+    | "sans-serif-bold-italic"
+    | "sans-serif-italic"
+    | "script";
+
+export type FontName =
+    | "AMS-Regular"
+    | "Caligraphic-Regular"
+    | "Fraktur-Regular"
+    | "Main-Bold"
+    | "Main-BoldItalic"
+    | "Main-Italic"
+    | "Main-Regular"
+    | "Math-BoldItalic"
+    | "Math-Italic"
+    | "SansSerif-Regular"
+    | "SansSerif-Bold"
+    | "SansSerif-Italic"
+    | "Script-Regular"
+    | "Size1-Regular"
+    | "Size2-Regular"
+    | "Size3-Regular"
+    | "Size4-Regular"
+    | "Typewriter-Regular";
+
+//[depth, height, italic, skew, width]
+export type CharacterMetricsTuple = [depth: number, height: number, italic: number, skew: number, width: number];
+
+export type CharacterMetrics = {
+    depth: number;
+    height: number;
+    italic: number;
+    skew: number;
+    width: number;
+};
+
+export type FontMetrics = {
+    cssEmPerMu: number;
+    [key: string]: number;
+};
+
+export type SymbolFont = "main" | "ams";
+
+export type MathFont =
+    | ""
+    | "mathrm"
+    | "mathit"
+    | "mathbf"
+    | "mathnormal"
+    | "mathsfit"
+    | "mathbb"
+    | "mathcal"
+    | "mathfrak"
+    | "mathscr"
+    | "mathsf"
+    | "mathtt"
+    | "boldsymbol";
+
+export type TextFont = "textrm" | "textsf" | "texttt" | "amsrm" | "";
+
+// In these types, "" (empty string) means "no change".
+export type FontWeight = "textbf" | "textmd" | "";
+export type FontShape = "textit" | "textup" | "";

package/plugin/node_modules/katex/src/types/index.ts

@@ -0,0 +1,29 @@
+export type Mode = "math" | "text";
+
+// LaTeX argument type.
+//   - "size": A size-like thing, such as "1em" or "5ex"
+//   - "color": An html color, like "#abc" or "blue"
+//   - "url": An url string, in which "\" will be ignored
+//   -        if it precedes [#$%&~_^\{}]
+//   - "raw": A string, allowing single character, percent sign,
+//            and nested braces
+//   - "original": The same type as the environment that the
+//                 function being parsed is in (e.g. used for the
+//                 bodies of functions like \textcolor where the
+//                 first argument is special and the second
+//                 argument is parsed normally)
+//   - Mode: Node group parsed in given mode.
+export type ArgType = "color" | "size" | "url" | "raw" | "original" | "hbox" |
+    "primitive" | Mode;
+
+// LaTeX display style.
+export type StyleStr = "text" | "display" | "script" | "scriptscript";
+
+// Allowable token text for "break" arguments in parser.
+export type BreakToken = "]" | "}" | "\\endgroup" | "$" | "\\)" | "\\\\" | "\\end" |
+    "EOF";
+
+export type DelimiterSize = 1 | 2 | 3 | 4;
+
+export type Slice1<S extends string> =
+    S extends `${string}${infer Rest}` ? Rest : "";

package/plugin/node_modules/katex/src/unicodeAccents.js

@@ -0,0 +1,21 @@
+// Mapping of Unicode accent characters to their LaTeX equivalent in text and
+// math mode (when they exist).
+// This exports a CommonJS module, allowing to be required in unicodeSymbols
+// without transpiling.
+/** @type {Record<string, {text: string, math?: string}>} */
+const unicodeAccents = {
+    '\u0301': {text: "\\'", math: '\\acute'},
+    '\u0300': {text: '\\`', math: '\\grave'},
+    '\u0308': {text: '\\"', math: '\\ddot'},
+    '\u0303': {text: '\\~', math: '\\tilde'},
+    '\u0304': {text: '\\=', math: '\\bar'},
+    '\u0306': {text: '\\u', math: '\\breve'},
+    '\u030c': {text: '\\v', math: '\\check'},
+    '\u0302': {text: '\\^', math: '\\hat'},
+    '\u0307': {text: '\\.', math: '\\dot'},
+    '\u030a': {text: '\\r', math: '\\mathring'},
+    '\u030b': {text: '\\H'},
+    '\u0327': {text: '\\c'},
+};
+
+module.exports = unicodeAccents;

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

@@ -0,0 +1,124 @@
+/*
+ * This file defines the Unicode scripts and script families that we
+ * support. To add new scripts or families, just add a new entry to the
+ * scriptData array below. Adding scripts to the scriptData array allows
+ * characters from that script to appear in \text{} environments.
+ */
+
+/**
+ * Each script or script family has a name and an array of blocks.
+ * Each block is an array of two numbers which specify the start and
+ * end points (inclusive) of a block of Unicode codepoints.
+ */
+type Script = {
+    name: string;
+    blocks: Array<Array<number>>;
+};
+
+/**
+ * Unicode block data for the families of scripts we support in \text{}.
+ * Scripts only need to appear here if they do not have font metrics.
+ */
+const scriptData: Array<Script> = [
+    {
+        // Latin characters beyond the Latin-1 characters we have metrics for.
+        // Needed for Czech, Hungarian and Turkish text, for example.
+        name: 'latin',
+        blocks: [
+            [0x0100, 0x024f],  // Latin Extended-A and Latin Extended-B
+            [0x0300, 0x036f],  // Combining Diacritical marks
+        ],
+    },
+    {
+        // The Cyrillic script used by Russian and related languages.
+        // A Cyrillic subset used to be supported as explicitly defined
+        // symbols in symbols.js
+        name: 'cyrillic',
+        blocks: [[0x0400, 0x04ff]],
+    },
+    {
+        // Armenian
+        name: 'armenian',
+        blocks: [[0x0530, 0x058F]],
+    },
+    {
+        // The Brahmic scripts of South and Southeast Asia
+        // Devanagari (0900–097F)
+        // Bengali (0980–09FF)
+        // Gurmukhi (0A00–0A7F)
+        // Gujarati (0A80–0AFF)
+        // Oriya (0B00–0B7F)
+        // Tamil (0B80–0BFF)
+        // Telugu (0C00–0C7F)
+        // Kannada (0C80–0CFF)
+        // Malayalam (0D00–0D7F)
+        // Sinhala (0D80–0DFF)
+        // Thai (0E00–0E7F)
+        // Lao (0E80–0EFF)
+        // Tibetan (0F00–0FFF)
+        // Myanmar (1000–109F)
+        name: 'brahmic',
+        blocks: [[0x0900, 0x109F]],
+    },
+    {
+        name: 'georgian',
+        blocks: [[0x10A0, 0x10ff]],
+    },
+    {
+        // Chinese and Japanese.
+        // The "k" in cjk is for Korean, but we've separated Korean out
+        name: "cjk",
+        blocks: [
+            [0x3000, 0x30FF], // CJK symbols and punctuation, Hiragana, Katakana
+            [0x4E00, 0x9FAF], // CJK ideograms
+            [0xFF00, 0xFF60], // Fullwidth punctuation
+            // TODO: add halfwidth Katakana and Romanji glyphs
+        ],
+    },
+    {
+        // Korean
+        name: 'hangul',
+        blocks: [[0xAC00, 0xD7AF]],
+    },
+];
+
+/**
+ * Given a codepoint, return the name of the script or script family
+ * it is from, or null if it is not part of a known block
+ */
+export function scriptFromCodepoint(codepoint: number): string | null | undefined {
+    for (let i = 0; i < scriptData.length; i++) {
+        const script = scriptData[i];
+        for (let i = 0; i < script.blocks.length; i++) {
+            const block = script.blocks[i];
+            if (codepoint >= block[0] && codepoint <= block[1]) {
+                return script.name;
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * A flattened version of all the supported blocks in a single array.
+ * This is an optimization to make supportedCodepoint() fast.
+ */
+const allBlocks: Array<number> = [];
+scriptData.forEach(s => s.blocks.forEach(b => allBlocks.push(...b)));
+
+/**
+ * Given a codepoint, return true if it falls within one of the
+ * scripts or script families defined above and false otherwise.
+ *
+ * Micro benchmarks shows that this is faster than
+ * /[\u3000-\u30FF\u4E00-\u9FAF\uFF00-\uFF60\uAC00-\uD7AF\u0900-\u109F]/.test()
+ * in Firefox, Chrome and Node.
+ */
+export function supportedCodepoint(codepoint: number): boolean {
+    for (let i = 0; i < allBlocks.length; i += 2) {
+        if (codepoint >= allBlocks[i] && codepoint <= allBlocks[i + 1]) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,108 @@
+// Helpers for Parser.js handling of Unicode (sub|super)script characters.
+
+export const unicodeSubRegEx = /^[₊₋₌₍₎₀₁₂₃₄₅₆₇₈₉ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓᵦᵧᵨᵩᵪ]/;
+
+export const uSubsAndSups: Readonly<Record<string, string>> = Object.freeze({
+    '₊': '+',
+    '₋': '-',
+    '₌': '=',
+    '₍': '(',
+    '₎': ')',
+    '₀': '0',
+    '₁': '1',
+    '₂': '2',
+    '₃': '3',
+    '₄': '4',
+    '₅': '5',
+    '₆': '6',
+    '₇': '7',
+    '₈': '8',
+    '₉': '9',
+    '\u2090': 'a',
+    '\u2091': 'e',
+    '\u2095': 'h',
+    '\u1D62': 'i',
+    '\u2C7C': 'j',
+    '\u2096': 'k',
+    '\u2097': 'l',
+    '\u2098': 'm',
+    '\u2099': 'n',
+    '\u2092': 'o',
+    '\u209A': 'p',
+    '\u1D63': 'r',
+    '\u209B': 's',
+    '\u209C': 't',
+    '\u1D64': 'u',
+    '\u1D65': 'v',
+    '\u2093': 'x',
+    '\u1D66': 'β',
+    '\u1D67': 'γ',
+    '\u1D68': 'ρ',
+    '\u1D69': '\u03d5',
+    '\u1D6A': 'χ',
+    '⁺': '+',
+    '⁻': '-',
+    '⁼': '=',
+    '⁽': '(',
+    '⁾': ')',
+    '⁰': '0',
+    '¹': '1',
+    '²': '2',
+    '³': '3',
+    '⁴': '4',
+    '⁵': '5',
+    '⁶': '6',
+    '⁷': '7',
+    '⁸': '8',
+    '⁹': '9',
+    '\u1D2C': 'A',
+    '\u1D2E': 'B',
+    '\u1D30': 'D',
+    '\u1D31': 'E',
+    '\u1D33': 'G',
+    '\u1D34': 'H',
+    '\u1D35': 'I',
+    '\u1D36': 'J',
+    '\u1D37': 'K',
+    '\u1D38': 'L',
+    '\u1D39': 'M',
+    '\u1D3A': 'N',
+    '\u1D3C': 'O',
+    '\u1D3E': 'P',
+    '\u1D3F': 'R',
+    '\u1D40': 'T',
+    '\u1D41': 'U',
+    '\u2C7D': 'V',
+    '\u1D42': 'W',
+    '\u1D43': 'a',
+    '\u1D47': 'b',
+    '\u1D9C': 'c',
+    '\u1D48': 'd',
+    '\u1D49': 'e',
+    '\u1DA0': 'f',
+    '\u1D4D': 'g',
+    '\u02B0': 'h',
+    '\u2071': 'i',
+    '\u02B2': 'j',
+    '\u1D4F': 'k',
+    '\u02E1': 'l',
+    '\u1D50': 'm',
+    '\u207F': 'n',
+    '\u1D52': 'o',
+    '\u1D56': 'p',
+    '\u02B3': 'r',
+    '\u02E2': 's',
+    '\u1D57': 't',
+    '\u1D58': 'u',
+    '\u1D5B': 'v',
+    '\u02B7': 'w',
+    '\u02E3': 'x',
+    '\u02B8': 'y',
+    '\u1DBB': 'z',
+    '\u1D5D': 'β',
+    '\u1D5E': 'γ',
+    '\u1D5F': 'δ',
+    '\u1D60': '\u03d5',
+    '\u1D61': 'χ',
+    '\u1DBF': 'θ',
+});

package/plugin/node_modules/katex/src/unicodeSymbols.js

@@ -0,0 +1,33 @@
+// @ts-check
+// This is an internal module, not part of the KaTeX distribution,
+// whose purpose is to generate `unicodeSymbols` in Parser.js
+// In this way, only this module, and not the distribution/browser,
+// needs String's normalize function. As this file is not transpiled,
+// JSDoc type syntax is used.
+const accents = require('./unicodeAccents');
+
+/** @type {Record<string, string>} */
+const result = {};
+const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+    "αβγδεϵζηθϑικλμνξοπϖρϱςστυφϕχψωΓΔΘΛΞΠΣΥΦΨΩ";
+for (const letter of letters) {
+    for (const accent of Object.getOwnPropertyNames(accents)) {
+        const combined = letter + accent;
+        const normalized = combined.normalize('NFC');
+        if (normalized.length === 1) {
+            result[normalized] = combined;
+        }
+        for (const accent2 of Object.getOwnPropertyNames(accents)) {
+            if (accent === accent2) {
+                continue;
+            }
+            const combined2 = combined + accent2;
+            const normalized2 = combined2.normalize('NFC');
+            if (normalized2.length === 1) {
+                result[normalized2] = combined2;
+            }
+        }
+    }
+}
+
+module.exports = result;

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

@@ -0,0 +1,104 @@
+/**
+ * This file does conversion between units.  In particular, it provides
+ * calculateSize to convert other units into ems.
+ */
+
+import ParseError from "./ParseError";
+import Options from "./Options";
+
+// This table gives the number of TeX pts in one of each *absolute* TeX unit.
+// Thus, multiplying a length by this number converts the length from units
+// into pts.  Dividing the result by ptPerEm gives the number of ems
+// *assuming* a font size of ptPerEm (normal size, normal style).
+const ptPerUnit: Record<string, number> = {
+    // https://en.wikibooks.org/wiki/LaTeX/Lengths and
+    // https://tex.stackexchange.com/a/8263
+    "pt": 1,            // TeX point
+    "mm": 7227 / 2540,  // millimeter
+    "cm": 7227 / 254,   // centimeter
+    "in": 72.27,        // inch
+    "bp": 803 / 800,    // big (PostScript) points
+    "pc": 12,           // pica
+    "dd": 1238 / 1157,  // didot
+    "cc": 14856 / 1157, // cicero (12 didot)
+    "nd": 685 / 642,    // new didot
+    "nc": 1370 / 107,   // new cicero (12 new didot)
+    "sp": 1 / 65536,    // scaled point (TeX's internal smallest unit)
+    // https://tex.stackexchange.com/a/41371
+    "px": 803 / 800,    // \pdfpxdimen defaults to 1 bp in pdfTeX and LuaTeX
+};
+
+// Dictionary of relative units, for fast validity testing.
+const relativeUnit = {
+    "ex": true,
+    "em": true,
+    "mu": true,
+};
+
+export type Measurement = { number: number, unit: string };
+
+/**
+ * Determine whether the specified unit (either a string defining the unit
+ * or a "size" parse node containing a unit field) is valid.
+ */
+export const validUnit = function(unit: string | Measurement): boolean {
+    if (typeof unit !== "string") {
+        unit = unit.unit;
+    }
+    return (unit in ptPerUnit || unit in relativeUnit || unit === "ex");
+};
+
+/*
+ * Convert a "size" parse node (with numeric "number" and string "unit" fields,
+ * as parsed by functions.js argType "size") into a CSS em value for the
+ * current style/scale.  `options` gives the current options.
+ */
+export const calculateSize = function(
+        sizeValue: Measurement, options: Options): number {
+    let scale;
+    if (sizeValue.unit in ptPerUnit) {
+        // Absolute units
+        scale = ptPerUnit[sizeValue.unit]   // Convert unit to pt
+           / options.fontMetrics().ptPerEm  // Convert pt to CSS em
+           / options.sizeMultiplier;        // Unscale to make absolute units
+    } else if (sizeValue.unit === "mu") {
+        // `mu` units scale with scriptstyle/scriptscriptstyle.
+        scale = options.fontMetrics().cssEmPerMu;
+    } else {
+        // Other relative units always refer to the *textstyle* font
+        // in the current size.
+        let unitOptions;
+        if (options.style.isTight()) {
+            // isTight() means current style is script/scriptscript.
+            unitOptions = options.havingStyle(options.style.text());
+        } else {
+            unitOptions = options;
+        }
+        // TODO: In TeX these units are relative to the quad of the current
+        // *text* font, e.g. cmr10. KaTeX instead uses values from the
+        // comparably-sized *Computer Modern symbol* font. At 10pt, these
+        // match. At 7pt and 5pt, they differ: cmr7=1.138894, cmsy7=1.170641;
+        // cmr5=1.361133, cmsy5=1.472241. Consider $\scriptsize a\kern1emb$.
+        // TeX \showlists shows a kern of 1.13889 * fontsize;
+        // KaTeX shows a kern of 1.171 * fontsize.
+        if (sizeValue.unit === "ex") {
+            scale = unitOptions.fontMetrics().xHeight;
+        } else if (sizeValue.unit === "em") {
+            scale = unitOptions.fontMetrics().quad;
+        } else {
+            throw new ParseError("Invalid unit: '" + sizeValue.unit + "'");
+        }
+        if (unitOptions !== options) {
+            scale *= unitOptions.sizeMultiplier / options.sizeMultiplier;
+        }
+    }
+    return Math.min(sizeValue.number * scale, options.maxSize);
+};
+
+/**
+ * Round `n` to 4 decimal places, or to the nearest 1/10,000th em. See
+ * https://github.com/KaTeX/KaTeX/pull/2460.
+ */
+export const makeEm = function(n: number): string {
+    return +n.toFixed(4) + "em";
+};

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

@@ -0,0 +1,89 @@
+/**
+ * This file contains a list of utility functions which are useful in other
+ * files.
+ */
+
+import type {AnyParseNode} from "./parseNode";
+
+// hyphenate and escape adapted from Facebook's React under Apache 2 license
+const uppercase = /([A-Z])/g;
+export const hyphenate = (str: string): string =>
+    str.replace(uppercase, "-$1").toLowerCase();
+
+const ESCAPE_LOOKUP: Record<string, string> = {
+    "&": "&amp;",
+    ">": "&gt;",
+    "<": "&lt;",
+    "\"": "&quot;",
+    "'": "&#x27;",
+};
+
+const ESCAPE_REGEX = /[&><"']/g;
+
+/**
+ * Escapes text to prevent scripting attacks.
+ */
+export const escape = (text: unknown): string =>
+    String(text).replace(ESCAPE_REGEX, match => ESCAPE_LOOKUP[match]);
+
+/**
+ * Sometimes we want to pull out the innermost element of a group. In most
+ * cases, this will just be the group itself, but when ordgroups and colors have
+ * a single element, we want to pull that out.
+ */
+export const getBaseElem = (group: AnyParseNode): AnyParseNode => {
+    if (group.type === "ordgroup") {
+        if (group.body.length === 1) {
+            return getBaseElem(group.body[0]);
+        } else {
+            return group;
+        }
+    } else if (group.type === "color") {
+        if (group.body.length === 1) {
+            return getBaseElem(group.body[0]);
+        } else {
+            return group;
+        }
+    } else if (group.type === "font") {
+        return getBaseElem(group.body);
+    } else {
+        return group;
+    }
+};
+
+const characterNodesTypes = new Set(["mathord", "textord", "atom"]);
+
+/**
+ * TeXbook algorithms often reference "character boxes", which are simply groups
+ * with a single character in them. To decide if something is a character box,
+ * we find its innermost group, and see if it is a single character.
+ */
+export const isCharacterBox = (group: AnyParseNode): boolean =>
+    characterNodesTypes.has(getBaseElem(group).type);
+
+/**
+ * Return the protocol of a URL, or "_relative" if the URL does not specify a
+ * protocol (and thus is relative), or `null` if URL has invalid protocol
+ * (so should be outright rejected).
+ */
+export const protocolFromUrl = (url: string): string | null => {
+    // Check for possible leading protocol.
+    // https://url.spec.whatwg.org/#url-parsing strips leading whitespace
+    // (U+20) or C0 control (U+00-U+1F) characters.
+    const protocol = /^[\x00-\x20]*([^\\/#?]*?)(:|&#0*58|&#x0*3a|&colon)/i
+    .exec(url);
+    if (!protocol) {
+        return "_relative";
+    }
+    // Reject weird colons
+    if (protocol[2] !== ":") {
+        return null;
+    }
+    // Reject invalid characters in scheme according to
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+    if (!/^[a-zA-Z][a-zA-Z0-9+\-.]*$/.test(protocol[1])) {
+        return null;
+    }
+    // Lowercase the protocol
+    return protocol[1].toLowerCase();
+};