@rse/ase 0.0.31 → 0.0.32

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

@@ -0,0 +1,467 @@
+/**
+ * This file contains the “gullet” where macros are expanded
+ * until only non-macro tokens remain.
+ */
+
+import functions from "./functions";
+import symbols from "./symbols";
+import Lexer from "./Lexer";
+import {Token} from "./Token";
+import type {Mode} from "./types";
+import ParseError from "./ParseError";
+import SourceLocation from "./SourceLocation";
+import Namespace from "./Namespace";
+import macros from "./macros";
+
+import type {MacroContextInterface, MacroDefinition, MacroExpansion, MacroArg}
+    from "./defineMacro";
+import type Settings from "./Settings";
+
+// List of commands that act like macros but aren't defined as a macro,
+// function, or symbol.  Used in `isDefined`.
+export const implicitCommands = {
+    "^": true,           // Parser.js
+    "_": true,           // Parser.js
+    "\\limits": true,    // Parser.js
+    "\\nolimits": true,  // Parser.js
+};
+
+export default class MacroExpander implements MacroContextInterface {
+    settings: Settings;
+    expansionCount: number;
+    lexer!: Lexer;
+    macros: Namespace<MacroDefinition>;
+    stack: Token[];
+    mode: Mode;
+
+    constructor(input: string, settings: Settings, mode: Mode) {
+        this.settings = settings;
+        this.expansionCount = 0;
+        this.feed(input);
+        // Make new global namespace
+        this.macros = new Namespace(macros, settings.macros);
+        this.mode = mode;
+        this.stack = []; // contains tokens in REVERSE order
+    }
+
+    /**
+     * Feed a new input string to the same MacroExpander
+     * (with existing macros etc.).
+     */
+    feed(input: string) {
+        this.lexer = new Lexer(input, this.settings);
+    }
+
+    /**
+     * Switches between "text" and "math" modes.
+     */
+    switchMode(newMode: Mode) {
+        this.mode = newMode;
+    }
+
+    /**
+     * Start a new group nesting within all namespaces.
+     */
+    beginGroup() {
+        this.macros.beginGroup();
+    }
+
+    /**
+     * End current group nesting within all namespaces.
+     */
+    endGroup() {
+        this.macros.endGroup();
+    }
+
+    /**
+     * Ends all currently nested groups (if any), restoring values before the
+     * groups began.  Useful in case of an error in the middle of parsing.
+     */
+    endGroups() {
+        this.macros.endGroups();
+    }
+
+    /**
+     * Returns the topmost token on the stack, without expanding it.
+     * Similar in behavior to TeX's `\futurelet`.
+     */
+    future(): Token {
+        if (this.stack.length === 0) {
+            this.pushToken(this.lexer.lex());
+        }
+        return this.stack[this.stack.length - 1];
+    }
+
+    /**
+     * Remove and return the next unexpanded token.
+     */
+    popToken(): Token {
+        this.future();  // ensure non-empty stack
+        return this.stack.pop()!;
+    }
+
+    /**
+     * Add a given token to the token stack.  In particular, this get be used
+     * to put back a token returned from one of the other methods.
+     */
+    pushToken(token: Token) {
+        this.stack.push(token);
+    }
+
+    /**
+     * Append an array of tokens to the token stack.
+     */
+    pushTokens(tokens: Token[]) {
+        this.stack.push(...tokens);
+    }
+
+    /**
+     * Find an macro argument without expanding tokens and append the array of
+     * tokens to the token stack. Uses Token as a container for the result.
+     */
+    scanArgument(isOptional: boolean): Token | null | undefined {
+        let start;
+        let end;
+        let tokens;
+        if (isOptional) {
+            this.consumeSpaces(); // \@ifnextchar gobbles any space following it
+            if (this.future().text !== "[") {
+                return null;
+            }
+            start = this.popToken(); // don't include [ in tokens
+            ({tokens, end} = this.consumeArg(["]"]));
+        } else {
+            ({tokens, start, end} = this.consumeArg());
+        }
+
+        // indicate the end of an argument
+        this.pushToken(new Token("EOF", end.loc));
+
+        this.pushTokens(tokens);
+        return new Token("", SourceLocation.range(start, end));
+    }
+
+    /**
+     * Consume all following space tokens, without expansion.
+     */
+    consumeSpaces() {
+        for (;;) {
+            const token = this.future();
+            if (token.text === " ") {
+                this.stack.pop();
+            } else {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Consume an argument from the token stream, and return the resulting array
+     * of tokens and start/end token.
+     */
+    consumeArg(delims?: string[] | null | undefined): MacroArg {
+        // The argument for a delimited parameter is the shortest (possibly
+        // empty) sequence of tokens with properly nested {...} groups that is
+        // followed ... by this particular list of non-parameter tokens.
+        // The argument for an undelimited parameter is the next nonblank
+        // token, unless that token is ‘{’, when the argument will be the
+        // entire {...} group that follows.
+        const tokens: Token[] = [];
+        const isDelimited = delims && delims.length > 0;
+        if (!isDelimited) {
+            // Ignore spaces between arguments.  As the TeXbook says:
+            // "After you have said ‘\def\row#1#2{...}’, you are allowed to
+            //  put spaces between the arguments (e.g., ‘\row x n’), because
+            //  TeX doesn’t use single spaces as undelimited arguments."
+            this.consumeSpaces();
+        }
+        const start = this.future();
+        let tok;
+        let depth = 0;
+        let match = 0;
+        do {
+            tok = this.popToken();
+            tokens.push(tok);
+            if (tok.text === "{") {
+                ++depth;
+            } else if (tok.text === "}") {
+                --depth;
+                if (depth === -1) {
+                    throw new ParseError("Extra }", tok);
+                }
+            } else if (tok.text === "EOF") {
+                throw new ParseError("Unexpected end of input in a macro argument" +
+                    ", expected '" + (delims && isDelimited ? delims[match] : "}") +
+                    "'", tok);
+            }
+            if (delims && isDelimited) {
+                if ((depth === 0 || (depth === 1 && delims[match] === "{")) &&
+                    tok.text === delims[match]) {
+                    ++match;
+                    if (match === delims.length) {
+                        // don't include delims in tokens
+                        tokens.splice(-match, match);
+                        break;
+                    }
+                } else {
+                    match = 0;
+                }
+            }
+        } while (depth !== 0 || isDelimited);
+        // If the argument found ... has the form ‘{<nested tokens>}’,
+        // ... the outermost braces enclosing the argument are removed
+        if (start.text === "{" && tokens[tokens.length - 1].text === "}") {
+            tokens.pop();
+            tokens.shift();
+        }
+        tokens.reverse(); // to fit in with stack order
+        return {tokens, start, end: tok};
+    }
+
+    /**
+     * Consume the specified number of (delimited) arguments from the token
+     * stream and return the resulting array of arguments.
+     */
+    consumeArgs(numArgs: number, delimiters?: string[][]): Token[][] {
+        if (delimiters) {
+            if (delimiters.length !== numArgs + 1) {
+                throw new ParseError(
+                    "The length of delimiters doesn't match the number of args!");
+            }
+            const delims = delimiters[0];
+            for (let i = 0; i < delims.length; i++) {
+                const tok = this.popToken();
+                if (delims[i] !== tok.text) {
+                    throw new ParseError(
+                        "Use of the macro doesn't match its definition", tok);
+                }
+            }
+        }
+
+        const args: Token[][] = [];
+        for (let i = 0; i < numArgs; i++) {
+            args.push(this.consumeArg(delimiters && delimiters[i + 1]).tokens);
+        }
+        return args;
+    }
+
+    /**
+     * Increment `expansionCount` by the specified amount.
+     * Throw an error if it exceeds `maxExpand`.
+     */
+    countExpansion(amount: number): void {
+        this.expansionCount += amount;
+        if (this.expansionCount > this.settings.maxExpand) {
+            throw new ParseError("Too many expansions: infinite loop or " +
+                "need to increase maxExpand setting");
+        }
+    }
+
+    /**
+     * Expand the next token only once if possible.
+     *
+     * If the token is expanded, the resulting tokens will be pushed onto
+     * the stack in reverse order, and the number of such tokens will be
+     * returned.  This number might be zero or positive.
+     *
+     * If not, the return value is `false`, and the next token remains at the
+     * top of the stack.
+     *
+     * In either case, the next token will be on the top of the stack,
+     * or the stack will be empty (in case of empty expansion
+     * and no other tokens).
+     *
+     * Used to implement `expandAfterFuture` and `expandNextToken`.
+     *
+     * If expandableOnly, only expandable tokens are expanded and
+     * an undefined control sequence results in an error.
+     */
+    expandOnce(expandableOnly?: boolean): number | boolean {
+        const topToken = this.popToken();
+        const name = topToken.text;
+        const expansion = !topToken.noexpand ? this._getExpansion(name) : null;
+        if (expansion == null || (expandableOnly && expansion.unexpandable)) {
+            if (expandableOnly && expansion == null &&
+                    name[0] === "\\" && !this.isDefined(name)) {
+                throw new ParseError("Undefined control sequence: " + name);
+            }
+            this.pushToken(topToken);
+            return false;
+        }
+        this.countExpansion(1);
+        let tokens = expansion.tokens;
+        const args = this.consumeArgs(expansion.numArgs, expansion.delimiters);
+        if (expansion.numArgs) {
+            // paste arguments in place of the placeholders
+            tokens = tokens.slice(); // make a shallow copy
+            for (let i = tokens.length - 1; i >= 0; --i) {
+                let tok = tokens[i];
+                if (tok.text === "#") {
+                    if (i === 0) {
+                        throw new ParseError(
+                            "Incomplete placeholder at end of macro body",
+                            tok);
+                    }
+                    tok = tokens[--i]; // next token on stack
+                    if (tok.text === "#") { // ## → #
+                        tokens.splice(i + 1, 1); // drop first #
+                    } else if (/^[1-9]$/.test(tok.text)) {
+                        // replace the placeholder with the indicated argument
+                        tokens.splice(i, 2, ...args[+tok.text - 1]);
+                    } else {
+                        throw new ParseError(
+                            "Not a valid argument number",
+                            tok);
+                    }
+                }
+            }
+        }
+        // Concatenate expansion onto top of stack.
+        this.pushTokens(tokens);
+        return tokens.length;
+    }
+
+    /**
+     * Expand the next token only once (if possible), and return the resulting
+     * top token on the stack (without removing anything from the stack).
+     * Similar in behavior to TeX's `\expandafter\futurelet`.
+     * Equivalent to expandOnce() followed by future().
+     */
+    expandAfterFuture(): Token {
+        this.expandOnce();
+        return this.future();
+    }
+
+    /**
+     * Recursively expand first token, then return first non-expandable token.
+     */
+    expandNextToken(): Token {
+        for (;;) {
+            if (this.expandOnce() === false) {  // fully expanded
+                const token = this.stack.pop()!;
+                // the token after \noexpand is interpreted as if its meaning
+                // were ‘\relax’
+                if (token.treatAsRelax) {
+                    token.text = "\\relax";
+                }
+                return token;
+            }
+        }
+    }
+
+    /**
+     * Fully expand the given macro name and return the resulting list of
+     * tokens, or return `undefined` if no such macro is defined.
+     */
+    expandMacro(name: string): Token[] | undefined {
+        return this.macros.has(name)
+            ? this.expandTokens([new Token(name)]) : undefined;
+    }
+
+    /**
+     * Fully expand the given token stream and return the resulting list of
+     * tokens.  Note that the input tokens are in reverse order, but the
+     * output tokens are in forward order.
+     */
+    expandTokens(tokens: Token[]): Token[] {
+        const output: Token[] = [];
+        const oldStackLength = this.stack.length;
+        this.pushTokens(tokens);
+        while (this.stack.length > oldStackLength) {
+            // Expand only expandable tokens
+            if (this.expandOnce(true) === false) {  // fully expanded
+                const token = this.stack.pop()!;
+                if (token.treatAsRelax) {
+                    // the expansion of \noexpand is the token itself
+                    token.noexpand = false;
+                    token.treatAsRelax = false;
+                }
+                output.push(token);
+            }
+        }
+        // Count all of these tokens as additional expansions, to prevent
+        // exponential blowup from linearly many \edef's.
+        this.countExpansion(output.length);
+        return output;
+    }
+
+    /**
+     * Fully expand the given macro name and return the result as a string,
+     * or return `undefined` if no such macro is defined.
+     */
+    expandMacroAsText(name: string): string | undefined {
+        const tokens = this.expandMacro(name);
+        if (tokens) {
+            return tokens.map((token) => token.text).join("");
+        } else {
+            return tokens;
+        }
+    }
+
+    /**
+     * Returns the expanded macro as a reversed array of tokens and a macro
+     * argument count.  Or returns `null` if no such macro.
+     */
+    _getExpansion(name: string): MacroExpansion | null | undefined {
+        const definition = this.macros.get(name);
+
+        if (definition == null) { // mainly checking for undefined here
+            return definition;
+        }
+        // If a single character has an associated catcode other than 13
+        // (active character), then don't expand it.
+        if (name.length === 1) {
+            const catcode = this.lexer.catcodes[name];
+            if (catcode != null && catcode !== 13) {
+                return;
+            }
+        }
+        const expansion =
+            typeof definition === "function" ? definition(this) : definition;
+        if (typeof expansion === "string") {
+            let numArgs = 0;
+            if (expansion.includes("#")) {
+                const stripped = expansion.replace(/##/g, "");
+                while (stripped.includes("#" + (numArgs + 1))) {
+                    ++numArgs;
+                }
+            }
+            const bodyLexer = new Lexer(expansion, this.settings);
+            const tokens = [];
+            let tok = bodyLexer.lex();
+            while (tok.text !== "EOF") {
+                tokens.push(tok);
+                tok = bodyLexer.lex();
+            }
+            tokens.reverse(); // to fit in with stack using push and pop
+            const expanded = {tokens, numArgs};
+            return expanded;
+        }
+
+        return expansion;
+    }
+
+    /**
+     * Determine whether a command is currently "defined" (has some
+     * functionality), meaning that it's a macro (in the current group),
+     * a function, a symbol, or one of the special commands listed in
+     * `implicitCommands`.
+     */
+    isDefined(name: string): boolean {
+        return this.macros.has(name) ||
+            functions.hasOwnProperty(name) ||
+            symbols.math.hasOwnProperty(name) ||
+            symbols.text.hasOwnProperty(name) ||
+            implicitCommands.hasOwnProperty(name);
+    }
+
+    /**
+     * Determine whether a command is expandable.
+     */
+    isExpandable(name: string): boolean {
+        const macro = this.macros.get(name);
+        return macro != null ? typeof macro === "string"
+                || typeof macro === "function" || !macro.unexpandable
+            : functions.hasOwnProperty(name) && !functions[name].primitive;
+    }
+}

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

@@ -0,0 +1,127 @@
+
+/**
+ * A `Namespace` refers to a space of nameable things like macros or lengths,
+ * which can be `set` either globally or local to a nested group, using an
+ * undo stack similar to how TeX implements this functionality.
+ * Performance-wise, `get` and local `set` take constant time, while global
+ * `set` takes time proportional to the depth of group nesting.
+ */
+
+import ParseError from "./ParseError";
+export type Mapping<Value> = Record<string, Value>;
+
+export default class Namespace<Value> {
+    current: Mapping<Value>;
+    builtins: Mapping<Value>;
+    undefStack: Mapping<Value | null | undefined>[];
+
+    /**
+     * Both arguments are optional.  The first argument is an object of
+     * built-in mappings which never change.  The second argument is an object
+     * of initial (global-level) mappings, which will constantly change
+     * according to any global/top-level `set`s done.
+     */
+    constructor(builtins: Mapping<Value> = {},
+                globalMacros: Mapping<Value> = {}) {
+        this.current = globalMacros;
+        this.builtins = builtins;
+        this.undefStack = [];
+    }
+
+    /**
+     * Start a new nested group, affecting future local `set`s.
+     */
+    beginGroup() {
+        this.undefStack.push({});
+    }
+
+    /**
+     * End current nested group, restoring values before the group began.
+     */
+    endGroup() {
+        if (this.undefStack.length === 0) {
+            throw new ParseError("Unbalanced namespace destruction: attempt " +
+                "to pop global namespace; please report this as a bug");
+        }
+        const undefs = this.undefStack.pop();
+        for (const undef in undefs) {
+            if (undefs.hasOwnProperty(undef)) {
+                if (undefs[undef] == null) {
+                    delete this.current[undef];
+                } else {
+                    this.current[undef] = undefs[undef];
+                }
+            }
+        }
+    }
+
+    /**
+     * Ends all currently nested groups (if any), restoring values before the
+     * groups began.  Useful in case of an error in the middle of parsing.
+     */
+    endGroups() {
+        while (this.undefStack.length > 0) {
+            this.endGroup();
+        }
+    }
+
+    /**
+     * Detect whether `name` has a definition.  Equivalent to
+     * `get(name) != null`.
+     */
+    has(name: string): boolean {
+        return this.current.hasOwnProperty(name) ||
+               this.builtins.hasOwnProperty(name);
+    }
+
+    /**
+     * Get the current value of a name, or `undefined` if there is no value.
+     *
+     * Note: Do not use `if (namespace.get(...))` to detect whether a macro
+     * is defined, as the definition may be the empty string which evaluates
+     * to `false` in JavaScript.  Use `if (namespace.get(...) != null)` or
+     * `if (namespace.has(...))`.
+     */
+    get(name: string): Value | null | undefined {
+        if (this.current.hasOwnProperty(name)) {
+            return this.current[name];
+        } else {
+            return this.builtins[name];
+        }
+    }
+
+    /**
+     * Set the current value of a name, and optionally set it globally too.
+     * Local set() sets the current value and (when appropriate) adds an undo
+     * operation to the undo stack.  Global set() may change the undo
+     * operation at every level, so takes time linear in their number.
+     * A value of undefined means to delete existing definitions.
+     */
+    set(name: string, value: Value | null | undefined, global: boolean = false) {
+        if (global) {
+            // Global set is equivalent to setting in all groups.  Simulate this
+            // by destroying any undos currently scheduled for this name,
+            // and adding an undo with the *new* value (in case it later gets
+            // locally reset within this environment).
+            for (let i = 0; i < this.undefStack.length; i++) {
+                delete this.undefStack[i][name];
+            }
+            if (this.undefStack.length > 0) {
+                this.undefStack[this.undefStack.length - 1][name] = value;
+            }
+        } else {
+            // Undo this set at end of this group (possibly to `undefined`),
+            // unless an undo is already in place, in which case that older
+            // value is the correct one.
+            const top = this.undefStack[this.undefStack.length - 1];
+            if (top && !top.hasOwnProperty(name)) {
+                top[name] = this.current[name];
+            }
+        }
+        if (value == null) {
+            delete this.current[name];
+        } else {
+            this.current[name] = value;
+        }
+    }
+}