From 5b16b58dc4ce591b3a529f7f75588414faaff7d0 Mon Sep 17 00:00:00 2001 From: naskya Date: Sun, 26 Mar 2023 08:06:49 +0900 Subject: [PATCH] Substitute "command" for "macro" --- packages/client/src/scripts/katex-macro.ts | 110 ++++++++++----------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/packages/client/src/scripts/katex-macro.ts b/packages/client/src/scripts/katex-macro.ts index 62d4871054..d7c518a2bf 100644 --- a/packages/client/src/scripts/katex-macro.ts +++ b/packages/client/src/scripts/katex-macro.ts @@ -1,10 +1,10 @@ -type KaTeXCommand = { +type KaTeXMacro = { args: number; rule: (string | number)[]; }; -function parseSingleKaTeXCommand(src: string): [string, KaTeXCommand] { - const invalid: [string, KaTeXCommand] = ["", { args: 0, rule: [] }]; +function parseSingleKaTeXMacro(src: string): [string, KaTeXMacro] { + const invalid: [string, KaTeXMacro] = ["", { args: 0, rule: [] }]; const skipSpaces = (pos: number): number => { while (src[pos] === " ") @@ -12,10 +12,10 @@ function parseSingleKaTeXCommand(src: string): [string, KaTeXCommand] { return pos; }; - if (!src.startsWith("\\newcommand") || src.slice(-1) !== "}") + if (!src.startsWith("\\newmacro") || src.slice(-1) !== "}") return invalid; - // current index we are checking (= "\\newcommand".length) + // current index we are checking (= "\\newmacro".length) let currentPos: number = 11; currentPos = skipSpaces(currentPos); @@ -46,18 +46,18 @@ function parseSingleKaTeXCommand(src: string): [string, KaTeXCommand] { currentPos = skipSpaces(closeNameBracketPos + 1); - let command: KaTeXCommand = { args: 0, rule: [] }; + let macro: KaTeXMacro = { args: 0, rule: [] }; // parse [number of arguments] (optional) if (src[currentPos] === "[") { const closeArgsBracketPos: number = src.indexOf("]", currentPos); - command.args = Number(src.slice(currentPos + 1, closeArgsBracketPos).trim()); + macro.args = Number(src.slice(currentPos + 1, closeArgsBracketPos).trim()); currentPos = closeArgsBracketPos + 1; - if (Number.isNaN(command.args) || command.args < 0) + if (Number.isNaN(macro.args) || macro.args < 0) return invalid; } else if (src[currentPos] === "{") { - command.args = 0; + macro.args = 0; } else { return invalid; } @@ -90,43 +90,43 @@ function parseSingleKaTeXCommand(src: string): [string, KaTeXCommand] { } } if (numbersignPos === -1) { - command.rule.push(src.slice(currentPos, -1)); + macro.rule.push(src.slice(currentPos, -1)); break; } const argIndexEndPos = src.slice(numbersignPos + 1).search(/[^\d]/) + numbersignPos; const argIndex: number = Number(src.slice(numbersignPos + 1, argIndexEndPos + 1)); - if (Number.isNaN(argIndex) || argIndex < 1 || command.args < argIndex) + if (Number.isNaN(argIndex) || argIndex < 1 || macro.args < argIndex) return invalid; if (currentPos !== numbersignPos) - command.rule.push(src.slice(currentPos, numbersignPos)); - command.rule.push(argIndex); + macro.rule.push(src.slice(currentPos, numbersignPos)); + macro.rule.push(argIndex); currentPos = argIndexEndPos + 1; } - if (command.args === 0) - return [name, command]; + if (macro.args === 0) + return [name, macro]; else - return [name + bracket[0], command]; + return [name + bracket[0], macro]; } -export function parseKaTeXCommands(src: string): string { - let result: { [name: string]: KaTeXCommand } = {}; +export function parseKaTeXMacros(src: string): string { + let result: { [name: string]: KaTeXMacro } = {}; for (const s of src.split("\n")) { - const [name, command]: [string, KaTeXCommand] = parseSingleKaTeXCommand(s.trim()); + const [name, macro]: [string, KaTeXMacro] = parseSingleKaTeXMacro(s.trim()); if (name !== "") - result[name] = command; + result[name] = macro; } return JSON.stringify(result); } -export function expandKaTeXCommand(src: string, commandsAsJsonString: string): string { - const commands = JSON.parse(commandsAsJsonString); +export function expandKaTeXMacro(src: string, macrosAsJsonString: string): string { + const macros = JSON.parse(macrosAsJsonString); const bracketKinds = 3; const openBracketId: { [bracket: string]: number } = {"(": 0, "{": 1, "[": 2}; @@ -175,9 +175,9 @@ export function expandKaTeXCommand(src: string, commandsAsJsonString: string): s return result; })(); - function expandSingleKaTeXCommand(expandedArgs: string[], commandName: string): string { + function expandSingleKaTeXMacro(expandedArgs: string[], macroName: string): string { let result = ""; - for (const block of commands[commandName].rule) { + for (const block of macros[macroName].rule) { if (typeof block === "string") result += block; else @@ -190,7 +190,7 @@ export function expandKaTeXCommand(src: string, commandsAsJsonString: string): s const maxNumberOfExpansions = 200; // to prevent infinite expansion loop // only expand src.slice(beginPos, endPos) - function expandKaTeXCommandImpl(beginPos: number, endPos: number): string { + function expandKaTeXMacroImpl(beginPos: number, endPos: number): string { if (endPos <= beginPos) return ""; @@ -201,35 +201,35 @@ export function expandKaTeXCommand(src: string, commandsAsJsonString: string): s return fallback; ++numberOfExpansions; - // search for a custom command + // search for a custom macro let checkedPos = beginPos - 1; - let commandName = ""; - let commandBackslashPos = 0; + let macroName = ""; + let macroBackslashPos = 0; - // for commands w/o args: unused + // for macros w/o args: unused // w/ args: the first open bracket ("(", "{", or "[") after cmd name - let commandArgBeginPos = 0; + let macroArgBeginPos = 0; - // for commands w/o args: the end of cmd name + // for macros w/o args: the end of cmd name // w/ args: the closing bracket of the last arg - let commandArgEndPos = 0; + let macroArgEndPos = 0; while (checkedPos < endPos) { checkedPos = src.indexOf("\\", checkedPos + 1); - // there is no command to expand + // there is no macro to expand if (checkedPos === -1) return raw; - // is it a custom command? + // is it a custom macro? let nonAlphaPos = src.slice(checkedPos + 1).search(/[^A-Za-z]/) + checkedPos + 1; - let commandNameCandidate = src.slice(checkedPos + 1, nonAlphaPos); - if (commands.hasOwnProperty(commandNameCandidate)) { - // this is a custom command without args - commandBackslashPos = checkedPos; - commandArgEndPos = nonAlphaPos - 1; - commandName = commandNameCandidate; + let macroNameCandidate = src.slice(checkedPos + 1, nonAlphaPos); + if (macros.hasOwnProperty(macroNameCandidate)) { + // this is a custom macro without args + macroBackslashPos = checkedPos; + macroArgEndPos = nonAlphaPos - 1; + macroName = macroNameCandidate; break; } @@ -243,38 +243,38 @@ export function expandKaTeXCommand(src: string, commandsAsJsonString: string): s if (nextOpenBracketPos === endPos) return fallback; // there is no open bracket - commandNameCandidate += src[nextOpenBracketPos]; + macroNameCandidate += src[nextOpenBracketPos]; - if (commands.hasOwnProperty(commandNameCandidate)) { - commandBackslashPos = checkedPos; - commandArgBeginPos = nextOpenBracketPos; - commandArgEndPos = nextOpenBracketPos; // to search the first arg from here - commandName = commandNameCandidate; + if (macros.hasOwnProperty(macroNameCandidate)) { + macroBackslashPos = checkedPos; + macroArgBeginPos = nextOpenBracketPos; + macroArgEndPos = nextOpenBracketPos; // to search the first arg from here + macroName = macroNameCandidate; break; } } - const numArgs: number = commands[commandName].args; - const openBracket: string = commandName.slice(-1); + const numArgs: number = macros[macroName].args; + const openBracket: string = macroName.slice(-1); let expandedArgs = new Array(numArgs); for (let i = 0; i < numArgs; ++i) { // find the first open bracket after what we've searched - const nextOpenBracketPos = src.indexOf(openBracket, commandArgEndPos); + const nextOpenBracketPos = src.indexOf(openBracket, macroArgEndPos); if (nextOpenBracketPos === -1) return fallback; // not enough arguments are provided if (!bracketMapping[nextOpenBracketPos]) return fallback; // found open bracket doesn't correspond to any close bracket - commandArgEndPos = bracketMapping[nextOpenBracketPos]; - expandedArgs[i] = expandKaTeXCommandImpl(nextOpenBracketPos + 1, commandArgEndPos); + macroArgEndPos = bracketMapping[nextOpenBracketPos]; + expandedArgs[i] = expandKaTeXMacroImpl(nextOpenBracketPos + 1, macroArgEndPos); } - return src.slice(beginPos, commandBackslashPos) - + expandSingleKaTeXCommand(expandedArgs, commandName) - + expandKaTeXCommandImpl(commandArgEndPos + 1, endPos); + return src.slice(beginPos, macroBackslashPos) + + expandSingleKaTeXMacro(expandedArgs, macroName) + + expandKaTeXMacroImpl(macroArgEndPos + 1, endPos); } - return expandKaTeXCommandImpl(0, src.length); + return expandKaTeXMacroImpl(0, src.length); }