Merge pull request #708 from mathjax/amsmath-update

Amsmath update + flalign, xalign, xxalign.

Author: dpvc

ts/input/tex.ts

@@ -181,11 +181,13 @@ export class TeX<N, T, D> extends AbstractInputJax<N, T, D> {
     this.latex = math.math;
     let node: MmlNode;
     this.parseOptions.tags.startEquation(math);
+    let globalEnv;
     try {
       let parser = new TexParser(this.latex,
                                  {display: display, isInner: false},
                                  this.parseOptions);
       node = parser.mml();
+      globalEnv = parser.stack.global;
     } catch (err) {
       if (!(err instanceof TexError)) {
         throw err;
@@ -194,6 +196,9 @@ export class TeX<N, T, D> extends AbstractInputJax<N, T, D> {
       node = this.options.formatError(this, err);
     }
     node = this.parseOptions.nodeFactory.create('node', 'math', [node]);
+    if (globalEnv?.indentalign) {
+      NodeUtil.setAttribute(node, 'indentalign', globalEnv.indentalign);
+    }
     if (display) {
       NodeUtil.setAttribute(node, 'display', 'block');
     }

ts/input/tex/ParseUtil.ts

@@ -30,6 +30,7 @@ import NodeUtil from './NodeUtil.js';
 import TexParser from './TexParser.js';
 import TexError from './TexError.js';
 import {entities} from '../../util/Entities.js';
+import {em} from '../../util/lengths.js';
 
 
 namespace ParseUtil {
@@ -104,11 +105,18 @@ namespace ParseUtil {
    * @param {number} m The number.
    * @return {string} The em dimension string.
    */
-    export function Em(m: number): string {
-    if (Math.abs(m) < .0006) {
-      return '0em';
-    }
-    return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
+  export function Em(m: number): string {
+    return em(m);
+  }
+
+
+  /**
+   * Takes an array of numbers and returns a space-separated string of em values.
+   * @param {number[]} W  The widths to be turned into em values
+   * @return {string}     The numbers with em units, separated by spaces.
+   */
+  export function cols(...W: number[]): string {
+    return W.map(n => Em(n)).join(' ');
   }
 
 

ts/input/tex/Tags.ts

@@ -616,8 +616,6 @@ export namespace TagsFactory {
     tagSide: 'right',
     // This is the amount of indentation (from right or left) for the tags.
     tagIndent: '0.8em',
-    // This is the width to use for the multline environment
-    multlineWidth: '85%',
     // make element ID's use \label name rather than equation number
     // MJ puts in an equation prefix: mjx-eqn
     // When true it uses the label name XXX as mjx-eqn:XXX

ts/input/tex/ams/AmsConfiguration.ts

@@ -23,7 +23,7 @@
  */
 
 import {Configuration, ParserConfiguration} from '../Configuration.js';
-import {MultlineItem} from './AmsItems.js';
+import {MultlineItem, FlalignItem} from './AmsItems.js';
 import {AbstractTags} from '../Tags.js';
 import {NEW_OPS} from './AmsMethods.js';
 import './AmsMappings.js';
@@ -57,9 +57,28 @@ export const AmsConfiguration = Configuration.create(
               'AMSmath-mathchar0mo', 'AMSmath-macros', 'AMSmath-delimiter'],
       environment: ['AMSmath-environment']
     },
-    items: {[MultlineItem.prototype.kind]: MultlineItem},
+    items: {
+      [MultlineItem.prototype.kind]: MultlineItem,
+      [FlalignItem.prototype.kind]: FlalignItem,
+    },
     tags: {'ams': AmsTags},
-    init: init
+    init: init,
+    config: (_config: ParserConfiguration, jax: any)  => {
+      //
+      //  Move multlineWidth from old location to ams block (remove in next version)
+      //
+      if (jax.parseOptions.options.multlineWidth) {
+        jax.parseOptions.options.ams.multlineWidth = jax.parseOptions.options.multlineWidth;
+      }
+      delete jax.parseOptions.options.multlineWidth;
+    },
+    options: {
+      multlineWidth: '',
+      ams: {
+        multlineWidth: '100%',  // The width to use for multline environments.
+        multlineIndent: '1em',  // The margin to use on both sides of multline environments.
+      }
+    }
   }
 );
 

ts/input/tex/ams/AmsItems.ts

@@ -23,11 +23,12 @@
  */
 
 
-import {ArrayItem} from '../base/BaseItems.js';
+import {ArrayItem, EqnArrayItem} from '../base/BaseItems.js';
 import ParseUtil from '../ParseUtil.js';
 import NodeUtil from '../NodeUtil.js';
 import TexError from '../TexError.js';
 import {TexConstant} from '../TexConstants.js';
+import {MmlNode} from '../../../core/MmlTree/MmlNode.js';
 
 
 /**
@@ -117,3 +118,107 @@ export class MultlineItem extends ArrayItem {
     this.factory.configuration.tags.end();
   }
 }
+
+/**
+ * StackItem for handling flalign, xalignat, and xxalignat environments.
+ */
+export class FlalignItem extends EqnArrayItem {
+
+  /**
+   * @override
+   */
+  get kind() {
+    return 'flalign';
+  }
+
+
+  /**
+   * @override
+   */
+  constructor(factory: any, public name: string, public numbered: boolean,
+              public padded: boolean, public center: boolean) {
+    super(factory);
+    this.factory.configuration.tags.start(name, numbered, numbered);
+  }
+
+  /**
+   * @override
+   */
+  public EndEntry() {
+    super.EndEntry();
+    const n = this.getProperty('xalignat') as number;
+    if (!n) return;
+    if (this.row.length > n) {
+      throw new TexError('XalignOverflow', 'Extra %1 in row of %2', '&', this.name);
+    }
+  }
+
+
+  /**
+   * @override
+   */
+  public EndRow() {
+    let cell: MmlNode;
+    let row = this.row;
+    //
+    //  For xalignat and xxalignat, pad the row to the expected number if it is too short.
+    //
+    const n = this.getProperty('xalignat') as number;
+    while (row.length < n) {
+      row.push(this.create('node', 'mtd'));
+    }
+    //
+    //  Insert padding cells between pairs of entries, as needed for "fit" columns,
+    //    and include initial and end cells if that is needed.
+    //
+    this.row = [];
+    if (this.padded) {
+      this.row.push(this.create('node', 'mtd'));
+    }
+    while ((cell = row.shift())) {
+      this.row.push(cell);
+      cell = row.shift();
+      if (cell) this.row.push(cell);
+      if (row.length || this.padded) {
+        this.row.push(this.create('node', 'mtd'));
+      }
+    }
+    //
+    if (this.row.length > this.maxrow) {
+      this.maxrow = this.row.length;
+    }
+    super.EndRow();
+    //
+    // For full-width environments with labels that aren't supposed to take up space,
+    //   move the label into a zero-width mpadded element that laps in the proper direction.
+    //
+    const mtr = this.table[this.table.length - 1];
+    if (this.getProperty('zeroWidthLabel') && mtr.isKind('mlabeledtr')) {
+      const mtd = NodeUtil.getChildren(mtr)[0];
+      const side = this.factory.configuration.options['tagSide'];
+      const def = {width: 0, ...(side === 'right' ? {lspace: '-1width'} : {})};
+      const mpadded = this.create('node', 'mpadded', NodeUtil.getChildren(mtd), def);
+      mtd.setChildren([mpadded]);
+    }
+  }
+
+
+  /**
+   * @override
+   */
+  public EndTable() {
+    super.EndTable();
+    if (this.center) {
+      //
+      //  If there is only one equation (one pair):
+      //    Don't make it 100%, and don't change the indentalign.
+      //
+      if (this.maxrow <= 2) {
+        const def = this.arraydef;
+        delete def.width;
+        delete this.global.indentalign;
+      }
+    }
+  }
+
+}

ts/input/tex/ams/AmsMappings.ts

@@ -29,16 +29,7 @@ import {TexConstant} from '../TexConstants.js';
 import ParseMethods from '../ParseMethods.js';
 import ParseUtil from '../ParseUtil.js';
 import {TEXCLASS} from '../../../core/MmlTree/MmlNode.js';
-import {MATHSPACE, em} from '../../../util/lengths.js';
-
-
-let COLS = function(W: number[]) {
-  const WW: string[] = [];
-  for (let i = 0, m = W.length; i < m; i++) {
-    WW[i] = ParseUtil.Em(W[i]);
-  }
-  return WW.join(' ');
-};
+import {MATHSPACE} from '../../../util/lengths.js';
 
 
 /**
@@ -107,28 +98,32 @@ new sm.CommandMap('AMSmath-macros', {
  * Environments from the AMS Math package.
  */
 new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, {
+  'equation*':   ['Equation', null, false],
   'eqnarray*':   ['EqnArray', null, false, true, 'rcl',
-                  '0 ' + em(MATHSPACE.thickmathspace), '.5em'],
-  align:         ['EqnArray', null, true, true,  'rlrlrlrlrlrl',
-                  COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0])],
-  'align*':      ['EqnArray', null, false, true, 'rlrlrlrlrlrl',
-                  COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0])],
+                  ParseUtil.cols(0, MATHSPACE.thickmathspace), '.5em'],
+  align:         ['EqnArray', null, true, true,  'rl',  ParseUtil.cols(0, 2)],
+  'align*':      ['EqnArray', null, false, true, 'rl',  ParseUtil.cols(0, 2)],
   multline:      ['Multline', null, true],
   'multline*':   ['Multline', null, false],
-  split:         ['EqnArray', null, false, false, 'rl', COLS([0])],
+  split:         ['EqnArray', null, false, false, 'rl', ParseUtil.cols(0)],
   gather:        ['EqnArray', null, true, true,  'c'],
   'gather*':     ['EqnArray', null, false, true, 'c'],
 
   alignat:       ['AlignAt', null, true, true],
   'alignat*':    ['AlignAt', null, false, true],
   alignedat:     ['AlignAt', null, false, false],
 
-  aligned:       ['AmsEqnArray', null, null, null, 'rlrlrlrlrlrl',
-                  COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0]), '.5em', 'D'],
+  aligned:       ['AmsEqnArray', null, null, null, 'rl', ParseUtil.cols(0, 2), '.5em', 'D'],
   gathered:      ['AmsEqnArray', null, null, null, 'c', null, '.5em', 'D'],
 
-  subarray:      ['Array', null, null, null, null, COLS([0]), '0.1em', 'S', 1],
-  smallmatrix:   ['Array', null, null, null, 'c', COLS([1 / 3]),
+  xalignat:      ['XalignAt', null, true, true],
+  'xalignat*':   ['XalignAt', null, false, true],
+  xxalignat:     ['XalignAt', null, false, false],
+  flalign:       ['FlalignArray', null, true, false, true, 'rlc', 'auto auto fit'],
+  'flalign*':    ['FlalignArray', null, false, false, true, 'rlc', 'auto auto fit'],
+
+  subarray:      ['Array', null, null, null, null, ParseUtil.cols(0), '0.1em', 'S', 1],
+  smallmatrix:   ['Array', null, null, null, 'c', ParseUtil.cols(1 / 3),
                   '.2em', 'S', 1],
   matrix:       ['Array', null, null, null, 'c'],
   pmatrix:      ['Array', null, '(', ')', 'c'],

ts/input/tex/ams/AmsMethods.ts

@@ -33,6 +33,7 @@ import TexError from '../TexError.js';
 import {Macro} from '../Symbol.js';
 import {CommandMap} from '../SymbolMap.js';
 import {ArrayItem} from '../base/BaseItems.js';
+import {FlalignItem} from './AmsItems.js';
 import BaseMethods from '../base/BaseMethods.js';
 import {TEXCLASS} from '../../../core/MmlTree/MmlNode.js';
 import {MmlMunderover} from '../../../core/MmlTree/MmlNodes/munderover.js';
@@ -118,15 +119,81 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b
   item.arraydef = {
     displaystyle: true,
     rowspacing: '.5em',
-    columnwidth: '100%',
-    width: parser.options['multlineWidth'],
+    columnspacing: '100%',
+    width: parser.options.ams['multlineWidth'],
     side: parser.options['tagSide'],
-    minlabelspacing: parser.options['tagIndent']
+    minlabelspacing: parser.options['tagIndent'],
+    framespacing: parser.options.ams['multlineIndent'] + ' 0',
+    frame: '',   // Use frame spacing with no actual frame
+    'data-width-includes-label': true // take label space out of 100% width
   };
   return item;
 };
 
 
+/**
+ * Generate an align at environment.
+ * @param {TexParser} parser The current TeX parser.
+ * @param {StackItem} begin The begin stackitem.
+ * @param {boolean} numbered Is this a numbered array.
+ * @param {boolean} padded Is it padded.
+ */
+AmsMethods.XalignAt = function(parser: TexParser, begin: StackItem,
+                                  numbered: boolean, padded: boolean) {
+  let n = parser.GetArgument('\\begin{' + begin.getName() + '}');
+  if (n.match(/[^0-9]/)) {
+    throw new TexError('PositiveIntegerArg',
+                       'Argument to %1 must me a positive integer',
+                       '\\begin{' + begin.getName() + '}');
+  }
+  const align = (padded ? 'crl' : 'rlc');
+  const width = (padded ? 'fit auto auto' : 'auto auto fit');
+  const item = AmsMethods.FlalignArray(parser, begin, numbered, padded, false, align, width, true) as FlalignItem;
+  item.setProperty('xalignat', 2 * parseInt(n));
+  return item;
+};
+
+
+/**
+ * Generate an flalign environment.
+ * @param {TexParser} parser The current TeX parser.
+ * @param {StackItem} begin The begin stackitem.
+ * @param {boolean} numbered Is this a numbered array.
+ * @param {boolean} padded Is it padded.
+ * @param {boolean} center Is it centered.
+ * @param {string} align The horizontal alignment for columns
+ * @param {string} width The column widths of the table
+ * @param {boolean} zeroWidthLabel True if the label should be in llap/rlap
+ */
+AmsMethods.FlalignArray = function(parser: TexParser, begin: StackItem, numbered: boolean,
+                                  padded: boolean, center: boolean, align: string,
+                                  width: string, zeroWidthLabel: boolean = false) {
+  parser.Push(begin);
+  ParseUtil.checkEqnEnv(parser);
+  align = align
+    .split('')
+    .join(' ')
+    .replace(/r/g, 'right')
+    .replace(/l/g, 'left')
+    .replace(/c/g, 'center');
+  const item = parser.itemFactory.create(
+    'flalign', begin.getName(), numbered, padded, center, parser.stack) as FlalignItem;
+  item.arraydef = {
+    width: '100%',
+    displaystyle: true,
+    columnalign: align,
+    columnspacing: '0em',
+    columnwidth: width,
+    rowspacing: '3pt',
+    side: parser.options['tagSide'],
+    minlabelspacing: (zeroWidthLabel ? '0' : parser.options['tagIndent']),
+    'data-width-includes-label': true,
+  };
+  item.setProperty('zeroWidthLabel', zeroWidthLabel);
+  return item;
+};
+
+
 export const NEW_OPS = 'ams-declare-ops';
 
 /**
@@ -405,3 +472,5 @@ AmsMethods.Spacer = BaseMethods.Spacer;
 AmsMethods.NamedOp = BaseMethods.NamedOp;
 
 AmsMethods.EqnArray = BaseMethods.EqnArray;
+
+AmsMethods.Equation = BaseMethods.Equation;