Add spaces afer @param and @return, as per Volker's request.

Author: dpvc

mathjax3-ts/adaptors/browserAdaptor.ts

@@ -40,7 +40,7 @@ declare global {
 /**
  * Function to create an HTML adpator for browsers
  *
- * @return{HTMLAdaptor}  The newly created adaptor
+ * @return {HTMLAdaptor}  The newly created adaptor
  */
 export function browserAdaptor() {
     return new HTMLAdaptor<HTMLElement, Text, Document>(window);

mathjax3-ts/adaptors/jsdomAdaptor.ts

@@ -26,8 +26,8 @@ import {HTMLAdaptor} from './HTMLAdaptor.js';
 /**
  * Function for creating an HTML adaptor using jsdom
  *
- * @param{any} JSDOM      The jsdom object to use for this adaptor
- * @return{HTMLAdaptor}   The newly created adaptor
+ * @param {any} JSDOM      The jsdom object to use for this adaptor
+ * @return {HTMLAdaptor}   The newly created adaptor
  */
 export function jsdomAdaptor(JSDOM: any) {
     return new HTMLAdaptor<HTMLElement, Text, Document>(new JSDOM().window);

mathjax3-ts/adaptors/lite/Element.ts

@@ -67,9 +67,9 @@ export class LiteElement {
     public styles: Styles;
 
     /**
-     * @param{string} kind  The type of node to create
-     * @param{LiteAttributeList} attributes  The list of attributes to set (if any)
-     * @param{LiteNode[]} children  The children for the node (if any)
+     * @param {string} kind  The type of node to create
+     * @param {LiteAttributeList} attributes  The list of attributes to set (if any)
+     * @param {LiteNode[]} children  The children for the node (if any)
      * @constructor
      */
     constructor(kind: string, attributes: LiteAttributeList = {}, children: LiteNode[] = []) {

mathjax3-ts/adaptors/lite/List.ts

@@ -36,15 +36,15 @@ export class LiteList<N> {
     public nodes: N[] = [];
 
     /**
-     * @param{N[]} children  The children for the fragment
+     * @param {N[]} children  The children for the fragment
      * @constructor
      */
     constructor(children: N[]) {
         this.nodes = [...children];
     }
 
     /**
-     * @param{N} node  A node to append to the fragment
+     * @param {N} node  A node to append to the fragment
      */
     public append(node: N) {
         this.nodes.push(node);

mathjax3-ts/adaptors/lite/Parser.ts

@@ -142,31 +142,31 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node to add a text element to
-     * @param{string} text          The text for the text node
-     * @return{LiteText}            The text element
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node to add a text element to
+     * @param {string} text          The text for the text node
+     * @return {LiteText}            The text element
      */
     protected addText(adaptor: LiteAdaptor, node: LiteElement, text: string) {
         text = Entities.translate(text);
         return adaptor.append(node, adaptor.text(text)) as LiteText;
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node to add a comment to
-     * @param{string} comment       The text for the comment node
-     * @return{LiteText}            The comment element
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node to add a comment to
+     * @param {string} comment       The text for the comment node
+     * @return {LiteText}            The comment element
      */
     protected addComment(adaptor: LiteAdaptor, node: LiteElement, comment: string) {
         return adaptor.append(node, new LiteComment(comment)) as LiteComment;
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node to close
-     * @param{string} tag           The close tag being processed
-     * @return{LiteElement}         The first unclosed parent node
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node to close
+     * @param {string} tag           The close tag being processed
+     * @return {LiteElement}         The first unclosed parent node
      */
     protected closeTag(adaptor: LiteAdaptor, node: LiteElement, tag: string) {
         const kind = tag.slice(2,tag.length - 1).toLowerCase();
@@ -177,11 +177,11 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The parent node for the tag
-     * @param{string} tag           The tag being processed
-     * @param{string[]} parts       The rest of the text/tag array
-     * @return{LiteElement}         The node to which the next tag will be added
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The parent node for the tag
+     * @param {string} tag           The tag being processed
+     * @param {string[]} parts       The rest of the text/tag array
+     * @return {LiteElement}         The node to which the next tag will be added
      */
     protected openTag(adaptor: LiteAdaptor, node: LiteElement, tag: string, parts: string[]) {
         const PCDATA = (this.constructor as typeof LiteParser).PCDATA;
@@ -223,9 +223,9 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node getting the attributes
-     * @param{string[]} attributes  The array of space, name, value1, value2, value3
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node getting the attributes
+     * @param {string[]} attributes  The array of space, name, value1, value2, value3
      *                                as described above.
      */
     protected addAttributes(adaptor: LiteAdaptor, node: LiteElement, attributes: string[]) {
@@ -241,10 +241,10 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node whose PCDATA content is being collected
-     * @param{string} kind          The tag name being handled
-     * @param{string[]} parts       The array of text/tag data for the document
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node whose PCDATA content is being collected
+     * @param {string} kind          The tag name being handled
+     * @param {string[]} parts       The array of text/tag data for the document
      */
     protected handlePCDATA(adaptor: LiteAdaptor, node: LiteElement, kind: string, parts: string[]) {
         const pcdata = [] as string[];
@@ -271,8 +271,8 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
      * tags into the document structure.  That way, you can parse fragements or
      * full documents and still get a valid document.
      *
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteDocuemnt} root    The document being checked
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteDocuemnt} root    The document being checked
      */
     protected checkDocument(adaptor: LiteAdaptor, root: LiteDocument) {
         if (adaptor.childNodes(adaptor.body(root)).length !== 1) return;
@@ -316,9 +316,9 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node to serialize
-     * @return{string}              The serialized element (like outerHTML)
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node to serialize
+     * @return {string}              The serialized element (like outerHTML)
      */
     public serialize(adaptor: LiteAdaptor, node: LiteElement) {
         const SELF_CLOSING = (this.constructor as typeof LiteParser).SELF_CLOSING;
@@ -334,9 +334,9 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{LiteAdaptor} adaptor  The adaptor for managing nodes
-     * @param{LiteElement} node     The node whose innerHTML is needed
-     * @return{string}              The serialized element (like innerHTML)
+     * @param {LiteAdaptor} adaptor  The adaptor for managing nodes
+     * @param {LiteElement} node     The node whose innerHTML is needed
+     * @return {string}              The serialized element (like innerHTML)
      */
     public serializeInner(adaptor: LiteAdaptor, node: LiteElement) {
         return adaptor.childNodes(node).map(x => {
@@ -348,16 +348,16 @@ export class LiteParser implements MinDOMParser<LiteDocument> {
     }
 
     /**
-     * @param{string} text  The attribute value to be HTML escaped
-     * @return{string}      The string with " replaced by entities
+     * @param {string} text  The attribute value to be HTML escaped
+     * @return {string}      The string with " replaced by entities
      */
     public protectAttribute(text: string) {
         return text.replace(/"/, '&quot;');
     }
 
     /**
-     * @param{string} text  The text to be HTML escaped
-     * @return{string}      The string with &, <, and > replaced by entities
+     * @param {string} text  The text to be HTML escaped
+     * @return {string}      The string with &, <, and > replaced by entities
      */
     public protectHTML(text: string) {
         return text.replace(/&/g, '&amp;')

mathjax3-ts/adaptors/lite/Text.ts

@@ -46,7 +46,7 @@ export class LiteText {
     }
 
     /**
-     * @param{string} text  The text for the node
+     * @param {string} text  The text for the node
      * @constructor
      */
     constructor(text: string = "") {

mathjax3-ts/adaptors/liteAdaptor.ts

@@ -64,7 +64,7 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
     public parser: LiteParser;
 
     /**
-     * @param{OptionList} options  The options for the lite adaptor (e.g., fontSize)
+     * @param {OptionList} options  The options for the lite adaptor (e.g., fontSize)
      * @constructor
      */
     constructor(options: OptionList = null) {
@@ -97,15 +97,15 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
     }
 
     /**
-     * @param{string} text   The text of the comment
-     * @return{LiteComment}  The comment node
+     * @param {string} text   The text of the comment
+     * @return {LiteComment}  The comment node
      */
     public comment(text: string) {
         return new LiteComment(text);
     }
 
     /**
-     * @return{LiteDocument}  A new document element
+     * @return {LiteDocument}  A new document element
      */
     public createDocument() {
         return new LiteDocument();
@@ -159,9 +159,9 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
     }
 
     /**
-     * @param{LiteELement} node   The node to be searched
-     * @param{string} id          The id of the node to look for
-     * @return{LiteElement}       The child node having the given id
+     * @param {LiteELement} node   The node to be searched
+     * @param {string} id          The id of the node to look for
+     * @return {LiteElement}       The child node having the given id
      */
     public elementById(node: LiteElement, id: string) {
         let stack = [] as LiteNode[];
@@ -182,9 +182,9 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
     }
 
     /**
-     * @param{LiteELement} node   The node to be searched
-     * @param{string} name        The name of the class to find
-     * @return{LiteElement[]}     The nodes with the given class
+     * @param {LiteELement} node   The node to be searched
+     * @param {string} name        The name of the class to find
+     * @return {LiteElement[]}     The nodes with the given class
      */
     public elementsByClass(node: LiteElement, name: string) {
         let stack = [] as LiteNode[];
@@ -243,8 +243,8 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
     }
 
     /**
-     * @param{LiteNode} node  The node whose index is needed
-     * @return{number}        THe index of the node it its parent's children array
+     * @param {LiteNode} node  The node whose index is needed
+     * @return {number}        THe index of the node it its parent's children array
      */
     public childIndex(node: LiteNode) {
         return (node.parent ? node.parent.children.findIndex(n => n === node) : -1);
@@ -539,8 +539,8 @@ export class LiteAdaptor extends AbstractDOMAdaptor<LiteElement, LiteText, LiteD
 /**
  * The function to call to obtain a LiteAdaptor
  *
- * @param{OptionList} options  The options for the adaptor
- * @return{LiteAdaptor}        The newly created adaptor
+ * @param {OptionList} options  The options for the adaptor
+ * @return {LiteAdaptor}        The newly created adaptor
  */
 export function liteAdaptor(options: OptionList = null) {
     return new LiteAdaptor(options);